rem0rec.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:13k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /************************************************************************
  2. Record manager
  3. (c) 1994-1996 Innobase Oy
  4. Created 5/30/1994 Heikki Tuuri
  5. *************************************************************************/
  6. #ifndef rem0rec_h
  7. #define rem0rec_h
  8. #include "univ.i"
  9. #include "data0data.h"
  10. #include "rem0types.h"
  11. #include "mtr0types.h"
  12. /* Maximum values for various fields (for non-blob tuples) */
  13. #define REC_MAX_N_FIELDS (1024 - 1)
  14. #define REC_MAX_HEAP_NO (2 * 8192 - 1)
  15. #define REC_MAX_N_OWNED (16 - 1)
  16. /* Flag denoting the predefined minimum record: this bit is ORed in the 4
  17. info bits of a record */
  18. #define REC_INFO_MIN_REC_FLAG 0x10UL
  19. /* Number of extra bytes in a record, in addition to the data and the
  20. offsets */
  21. #define REC_N_EXTRA_BYTES 6
  22. /**********************************************************
  23. The following function is used to get the offset of the
  24. next chained record on the same page. */
  25. UNIV_INLINE
  26. ulint 
  27. rec_get_next_offs(
  28. /*==============*/
  29. /* out: the page offset of the next 
  30. chained record */
  31. rec_t* rec); /* in: physical record */
  32. /**********************************************************
  33. The following function is used to set the next record offset field
  34. of the record. */
  35. UNIV_INLINE
  36. void
  37. rec_set_next_offs(
  38. /*==============*/
  39. rec_t* rec, /* in: physical record */
  40. ulint next); /* in: offset of the next record */
  41. /**********************************************************
  42. The following function is used to get the number of fields
  43. in the record. */
  44. UNIV_INLINE
  45. ulint
  46. rec_get_n_fields(
  47. /*=============*/
  48. /* out: number of data fields */
  49. rec_t* rec); /* in: physical record */
  50. /**********************************************************
  51. The following function is used to get the number of records
  52. owned by the previous directory record. */
  53. UNIV_INLINE
  54. ulint
  55. rec_get_n_owned(
  56. /*============*/
  57. /* out: number of owned records */
  58. rec_t* rec); /* in: physical record */
  59. /**********************************************************
  60. The following function is used to set the number of owned
  61. records. */
  62. UNIV_INLINE
  63. void
  64. rec_set_n_owned(
  65. /*============*/
  66. rec_t* rec, /* in: physical record */
  67. ulint n_owned); /* in: the number of owned */
  68. /**********************************************************
  69. The following function is used to retrieve the info bits of
  70. a record. */
  71. UNIV_INLINE
  72. ulint
  73. rec_get_info_bits(
  74. /*==============*/
  75. /* out: info bits */
  76. rec_t* rec); /* in: physical record */
  77. /**********************************************************
  78. The following function is used to set the info bits of a record. */
  79. UNIV_INLINE
  80. void
  81. rec_set_info_bits(
  82. /*==============*/
  83. rec_t* rec, /* in: physical record */
  84. ulint bits); /* in: info bits */
  85. /**********************************************************
  86. Gets the value of the deleted falg in info bits. */
  87. UNIV_INLINE
  88. ibool
  89. rec_info_bits_get_deleted_flag(
  90. /*===========================*/
  91. /* out: TRUE if deleted flag set */
  92. ulint info_bits); /* in: info bits from a record */
  93. /**********************************************************
  94. The following function tells if record is delete marked. */
  95. UNIV_INLINE
  96. ibool
  97. rec_get_deleted_flag(
  98. /*=================*/
  99. /* out: TRUE if delete marked */
  100. rec_t* rec); /* in: physical record */
  101. /**********************************************************
  102. The following function is used to set the deleted bit. */
  103. UNIV_INLINE
  104. void
  105. rec_set_deleted_flag(
  106. /*=================*/
  107. rec_t* rec, /* in: physical record */
  108. ibool flag); /* in: TRUE if delete marked */
  109. /**********************************************************
  110. The following function is used to get the order number
  111. of the record in the heap of the index page. */
  112. UNIV_INLINE
  113. ulint
  114. rec_get_heap_no(
  115. /*=============*/
  116. /* out: heap order number */
  117. rec_t* rec); /* in: physical record */
  118. /**********************************************************
  119. The following function is used to set the heap number
  120. field in the record. */
  121. UNIV_INLINE
  122. void
  123. rec_set_heap_no(
  124. /*=============*/
  125. rec_t* rec, /* in: physical record */
  126. ulint heap_no);/* in: the heap number */
  127. /**********************************************************
  128. The following function is used to test whether the data offsets
  129. in the record are stored in one-byte or two-byte format. */
  130. UNIV_INLINE
  131. ibool
  132. rec_get_1byte_offs_flag(
  133. /*====================*/
  134. /* out: TRUE if 1-byte form */
  135. rec_t* rec); /* in: physical record */
  136. /****************************************************************
  137. The following function is used to get a pointer to the nth
  138. data field in the record. */
  139. byte*
  140. rec_get_nth_field(
  141. /*==============*/
  142.   /* out: pointer to the field */
  143.   rec_t* rec,  /* in: record */
  144.   ulint n, /* in: index of the field */
  145. ulint* len); /* out: length of the field; UNIV_SQL_NULL 
  146. if SQL null */
  147. /****************************************************************
  148. Return field length or UNIV_SQL_NULL. */
  149. UNIV_INLINE
  150. ulint
  151. rec_get_nth_field_len(
  152. /*==================*/
  153.   /* out: length of the field; UNIV_SQL_NULL if SQL
  154. null */
  155.   rec_t* rec,  /* in: record */
  156.   ulint n); /* in: index of the field */
  157. /****************************************************************
  158. Gets the physical size of a field. Also an SQL null may have a field of
  159. size > 0, if the data type is of a fixed size. */
  160. UNIV_INLINE
  161. ulint
  162. rec_get_nth_field_size(
  163. /*===================*/
  164. /* out: field size in bytes */
  165.   rec_t* rec,  /* in: record */
  166.   ulint n); /* in: index of the field */
  167. /***************************************************************
  168. Gets the value of the ith field extern storage bit. If it is TRUE
  169. it means that the field is stored on another page. */
  170. UNIV_INLINE
  171. ibool
  172. rec_get_nth_field_extern_bit(
  173. /*=========================*/
  174. /* in: TRUE or FALSE */
  175. rec_t* rec, /* in: record */
  176. ulint i); /* in: ith field */
  177. /**********************************************************
  178. Returns TRUE if the extern bit is set in any of the fields
  179. of rec. */
  180. UNIV_INLINE
  181. ibool
  182. rec_contains_externally_stored_field(
  183. /*=================================*/
  184. /* out: TRUE if a field is stored externally */
  185. rec_t* rec); /* in: record */
  186. /***************************************************************
  187. Sets the value of the ith field extern storage bit. */
  188. void
  189. rec_set_nth_field_extern_bit(
  190. /*=========================*/
  191. rec_t* rec, /* in: record */
  192. ulint i, /* in: ith field */
  193. ibool val, /* in: value to set */
  194. mtr_t* mtr); /* in: mtr holding an X-latch to the page where
  195. rec is, or NULL; in the NULL case we do not
  196. write to log about the change */
  197. /***************************************************************
  198. Sets TRUE the extern storage bits of fields mentioned in an array. */
  199. void
  200. rec_set_field_extern_bits(
  201. /*======================*/
  202. rec_t* rec, /* in: record */
  203. ulint* vec, /* in: array of field numbers */
  204. ulint n_fields, /* in: number of fields numbers */
  205. mtr_t* mtr); /* in: mtr holding an X-latch to the page
  206. where rec is, or NULL; in the NULL case we
  207. do not write to log about the change */
  208. /****************************************************************
  209. The following function is used to get a copy of the nth
  210. data field in the record to a buffer. */
  211. UNIV_INLINE
  212. void
  213. rec_copy_nth_field(
  214. /*===============*/
  215.   void* buf, /* in: pointer to the buffer */
  216.   rec_t* rec,  /* in: record */
  217.   ulint n, /* in: index of the field */
  218. ulint* len); /* out: length of the field; UNIV_SQL_NULL if SQL 
  219. null */
  220. /*************************************************************** 
  221. This is used to modify the value of an already existing field in 
  222. a physical record. The previous value must have exactly the same 
  223. size as the new value. If len is UNIV_SQL_NULL then the field is 
  224. treated as SQL null. */
  225. UNIV_INLINE
  226. void
  227. rec_set_nth_field(
  228. /*==============*/
  229. rec_t* rec,  /* in: record */
  230. ulint n, /* in: index of the field */
  231. void* data, /* in: pointer to the data if not SQL null */
  232. ulint len); /* in: length of the data or UNIV_SQL_NULL. 
  233. If not SQL null, must have the same length as the
  234. previous value. If SQL null, previous value must be
  235. SQL null. */
  236. /************************************************************** 
  237. The following function returns the data size of a physical
  238. record, that is the sum of field lengths. SQL null fields
  239. are counted as length 0 fields. The value returned by the function
  240. is the distance from record origin to record end in bytes. */
  241. UNIV_INLINE
  242. ulint
  243. rec_get_data_size(
  244. /*==============*/
  245. /* out: size */
  246. rec_t* rec); /* in: physical record */
  247. /************************************************************** 
  248. Returns the total size of record minus data size of record.
  249. The value returned by the function is the distance from record 
  250. start to record origin in bytes. */
  251. UNIV_INLINE
  252. ulint
  253. rec_get_extra_size(
  254. /*===============*/
  255. /* out: size */
  256. rec_t* rec); /* in: physical record */
  257. /************************************************************** 
  258. Returns the total size of a physical record.  */
  259. UNIV_INLINE
  260. ulint
  261. rec_get_size(
  262. /*=========*/
  263. /* out: size */
  264. rec_t* rec); /* in: physical record */
  265. /**************************************************************
  266. Returns a pointer to the start of the record. */
  267. UNIV_INLINE
  268. byte*
  269. rec_get_start(
  270. /*==========*/
  271. /* out: pointer to start */
  272. rec_t* rec); /* in: pointer to record */
  273. /**************************************************************
  274. Returns a pointer to the end of the record. */
  275. UNIV_INLINE
  276. byte*
  277. rec_get_end(
  278. /*========*/
  279. /* out: pointer to end */
  280. rec_t* rec); /* in: pointer to record */
  281. /*******************************************************************
  282. Copies a physical record to a buffer. */
  283. UNIV_INLINE
  284. rec_t*
  285. rec_copy(
  286. /*=====*/
  287. /* out: pointer to the origin of the copied record */
  288. void* buf, /* in: buffer */
  289. rec_t* rec); /* in: physical record */
  290. /******************************************************************
  291. Copies the first n fields of a physical record to a new physical record in
  292. a buffer. */
  293. rec_t*
  294. rec_copy_prefix_to_buf(
  295. /*===================*/
  296. /* out, own: copied record */
  297. rec_t* rec, /* in: physical record */
  298. ulint n_fields, /* in: number of fields to copy */
  299. byte** buf, /* in/out: memory buffer for the copied prefix,
  300. or NULL */
  301. ulint* buf_size); /* in/out: buffer size */
  302. /****************************************************************
  303. Folds a prefix of a physical record to a ulint. */
  304. UNIV_INLINE
  305. ulint
  306. rec_fold(
  307. /*=====*/
  308. /* out: the folded value */
  309. rec_t* rec, /* in: the physical record */
  310. ulint n_fields, /* in: number of complete fields to fold */
  311. ulint n_bytes, /* in: number of bytes to fold in an
  312. incomplete last field */
  313. dulint tree_id); /* in: index tree id */
  314. /*************************************************************
  315. Builds a physical record out of a data tuple and stores it beginning from
  316. address destination. */
  317. UNIV_INLINE
  318. rec_t* 
  319. rec_convert_dtuple_to_rec(
  320. /*======================*/
  321. /* out: pointer to the origin of physical
  322. record */
  323. byte* destination, /* in: start address of the physical record */
  324. dtuple_t* dtuple); /* in: data tuple */
  325. /*************************************************************
  326. Builds a physical record out of a data tuple and stores it beginning from
  327. address destination. */
  328. rec_t* 
  329. rec_convert_dtuple_to_rec_low(
  330. /*==========================*/
  331. /* out: pointer to the origin of physical
  332. record */
  333. byte* destination, /* in: start address of the physical record */
  334. dtuple_t* dtuple, /* in: data tuple */
  335. ulint data_size); /* in: data size of dtuple */
  336. /**************************************************************
  337. Returns the extra size of a physical record if we know its
  338. data size and number of fields. */
  339. UNIV_INLINE
  340. ulint
  341. rec_get_converted_extra_size(
  342. /*=========================*/
  343. /* out: extra size */
  344. ulint data_size, /* in: data size */
  345. ulint n_fields); /* in: number of fields */
  346. /**************************************************************
  347. The following function returns the size of a data tuple when converted to
  348. a physical record. */
  349. UNIV_INLINE
  350. ulint
  351. rec_get_converted_size(
  352. /*===================*/
  353. /* out: size */
  354. dtuple_t* dtuple);/* in: data tuple */
  355. /******************************************************************
  356. Copies the first n fields of a physical record to a data tuple.
  357. The fields are copied to the memory heap. */
  358. void
  359. rec_copy_prefix_to_dtuple(
  360. /*======================*/
  361. dtuple_t* tuple, /* in: data tuple */
  362. rec_t* rec, /* in: physical record */
  363. ulint n_fields, /* in: number of fields to copy */
  364. mem_heap_t* heap); /* in: memory heap */
  365. /*******************************************************************
  366. Validates the consistency of a physical record. */
  367. ibool
  368. rec_validate(
  369. /*=========*/
  370. /* out: TRUE if ok */
  371. rec_t* rec); /* in: physical record */
  372. /*******************************************************************
  373. Prints a physical record. */
  374. void
  375. rec_print(
  376. /*======*/
  377. FILE* file, /* in: file where to print */
  378. rec_t* rec); /* in: physical record */
  379. #define REC_INFO_BITS 6 /* This is single byte bit-field */
  380. /* Maximum lengths for the data in a physical record if the offsets
  381. are given in one byte (resp. two byte) format. */
  382. #define REC_1BYTE_OFFS_LIMIT 0x7FUL
  383. #define REC_2BYTE_OFFS_LIMIT 0x7FFFUL
  384. /* The data size of record must be smaller than this because we reserve
  385. two upmost bits in a two byte offset for special purposes */
  386. #define REC_MAX_DATA_SIZE (16 * 1024)
  387. #ifndef UNIV_NONINL
  388. #include "rem0rec.ic"
  389. #endif
  390. #endif