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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Transaction undo log record
  3. (c) 1996 Innobase Oy
  4. Created 3/26/1996 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef trx0rec_h
  7. #define trx0rec_h
  8. #include "univ.i"
  9. #include "trx0types.h"
  10. #include "row0types.h"
  11. #include "mtr0mtr.h"
  12. #include "trx0sys.h"
  13. #include "dict0types.h"
  14. #include "que0types.h"
  15. #include "data0data.h"
  16. #include "rem0types.h"
  17. /***************************************************************************
  18. Copies the undo record to the heap. */
  19. UNIV_INLINE
  20. trx_undo_rec_t*
  21. trx_undo_rec_copy(
  22. /*==============*/
  23. /* out, own: copy of undo log record */
  24. trx_undo_rec_t* undo_rec, /* in: undo log record */
  25. mem_heap_t* heap); /* in: heap where copied */
  26. /**************************************************************************
  27. Reads the undo log record type. */
  28. UNIV_INLINE
  29. ulint
  30. trx_undo_rec_get_type(
  31. /*==================*/
  32. /* out: record type */
  33. trx_undo_rec_t* undo_rec); /* in: undo log record */
  34. /**************************************************************************
  35. Reads from an undo log record the record compiler info. */
  36. UNIV_INLINE
  37. ulint
  38. trx_undo_rec_get_cmpl_info(
  39. /*=======================*/
  40. /* out: compiler info */
  41. trx_undo_rec_t* undo_rec); /* in: undo log record */
  42. /**************************************************************************
  43. Returns TRUE if an undo log record contains an extern storage field. */
  44. UNIV_INLINE
  45. ibool
  46. trx_undo_rec_get_extern_storage(
  47. /*============================*/
  48. /* out: TRUE if extern */
  49. trx_undo_rec_t* undo_rec); /* in: undo log record */
  50. /**************************************************************************
  51. Reads the undo log record number. */
  52. UNIV_INLINE
  53. dulint
  54. trx_undo_rec_get_undo_no(
  55. /*=====================*/
  56. /* out: undo no */
  57. trx_undo_rec_t* undo_rec); /* in: undo log record */
  58. /**************************************************************************
  59. Reads from an undo log record the general parameters. */
  60. byte*
  61. trx_undo_rec_get_pars(
  62. /*==================*/
  63. /* out: remaining part of undo log
  64. record after reading these values */
  65. trx_undo_rec_t* undo_rec, /* in: undo log record */
  66. ulint* type, /* out: undo record type:
  67. TRX_UNDO_INSERT_REC, ... */
  68. ulint* cmpl_info, /* out: compiler info, relevant only
  69. for update type records */
  70. ibool* updated_extern, /* out: TRUE if we updated an
  71. externally stored fild */
  72. dulint* undo_no, /* out: undo log record number */
  73. dulint* table_id); /* out: table id */
  74. /***********************************************************************
  75. Builds a row reference from an undo log record. */
  76. byte*
  77. trx_undo_rec_get_row_ref(
  78. /*=====================*/
  79. /* out: pointer to remaining part of undo
  80. record */
  81. byte* ptr, /* in: remaining part of a copy of an undo log
  82. record, at the start of the row reference;
  83. NOTE that this copy of the undo log record must
  84. be preserved as long as the row reference is
  85. used, as we do NOT copy the data in the
  86. record! */
  87. dict_index_t* index, /* in: clustered index */
  88. dtuple_t** ref, /* out, own: row reference */
  89. mem_heap_t* heap); /* in: memory heap from which the memory
  90. needed is allocated */
  91. /***********************************************************************
  92. Skips a row reference from an undo log record. */
  93. byte*
  94. trx_undo_rec_skip_row_ref(
  95. /*======================*/
  96. /* out: pointer to remaining part of undo
  97. record */
  98. byte* ptr, /* in: remaining part in update undo log
  99. record, at the start of the row reference */
  100. dict_index_t* index); /* in: clustered index */
  101. /**************************************************************************
  102. Reads from an undo log update record the system field values of the old
  103. version. */
  104. byte*
  105. trx_undo_update_rec_get_sys_cols(
  106. /*=============================*/
  107. /* out: remaining part of undo log
  108. record after reading these values */
  109. byte* ptr, /* in: remaining part of undo log
  110. record after reading general
  111. parameters */
  112. dulint* trx_id, /* out: trx id */
  113. dulint* roll_ptr, /* out: roll ptr */
  114. ulint* info_bits); /* out: info bits state */
  115. /***********************************************************************
  116. Builds an update vector based on a remaining part of an undo log record. */
  117. byte*
  118. trx_undo_update_rec_get_update(
  119. /*===========================*/
  120. /* out: remaining part of the record,
  121. NULL if an error detected, which means that
  122. the record is corrupted */
  123. byte* ptr, /* in: remaining part in update undo log
  124. record, after reading the row reference
  125. NOTE that this copy of the undo log record must
  126. be preserved as long as the update vector is
  127. used, as we do NOT copy the data in the
  128. record! */
  129. dict_index_t* index, /* in: clustered index */
  130. ulint type, /* in: TRX_UNDO_UPD_EXIST_REC,
  131. TRX_UNDO_UPD_DEL_REC, or
  132. TRX_UNDO_DEL_MARK_REC; in the last case,
  133. only trx id and roll ptr fields are added to
  134. the update vector */
  135. dulint trx_id, /* in: transaction id from this undorecord */
  136. dulint roll_ptr,/* in: roll pointer from this undo record */
  137. ulint info_bits,/* in: info bits from this undo record */
  138. trx_t* trx, /* in: transaction */
  139. mem_heap_t* heap, /* in: memory heap from which the memory
  140. needed is allocated */
  141. upd_t** upd); /* out, own: update vector */
  142. /***********************************************************************
  143. Builds a partial row from an update undo log record. It contains the
  144. columns which occur as ordering in any index of the table. */
  145. byte*
  146. trx_undo_rec_get_partial_row(
  147. /*=========================*/
  148. /* out: pointer to remaining part of undo
  149. record */
  150. byte* ptr, /* in: remaining part in update undo log
  151. record of a suitable type, at the start of
  152. the stored index columns;
  153. NOTE that this copy of the undo log record must
  154. be preserved as long as the partial row is
  155. used, as we do NOT copy the data in the
  156. record! */
  157. dict_index_t* index, /* in: clustered index */
  158. dtuple_t** row, /* out, own: partial row */
  159. mem_heap_t* heap); /* in: memory heap from which the memory
  160. needed is allocated */
  161. /***************************************************************************
  162. Writes information to an undo log about an insert, update, or a delete marking
  163. of a clustered index record. This information is used in a rollback of the
  164. transaction and in consistent reads that must look to the history of this
  165. transaction. */
  166. ulint
  167. trx_undo_report_row_operation(
  168. /*==========================*/
  169. /* out: DB_SUCCESS or error code */
  170. ulint flags, /* in: if BTR_NO_UNDO_LOG_FLAG bit is
  171. set, does nothing */
  172. ulint op_type, /* in: TRX_UNDO_INSERT_OP or
  173. TRX_UNDO_MODIFY_OP */
  174. que_thr_t* thr, /* in: query thread */
  175. dict_index_t* index, /* in: clustered index */
  176. dtuple_t* clust_entry, /* in: in the case of an insert,
  177. index entry to insert into the
  178. clustered index, otherwise NULL */
  179. upd_t* update, /* in: in the case of an update,
  180. the update vector, otherwise NULL */
  181. ulint cmpl_info, /* in: compiler info on secondary
  182. index updates */
  183. rec_t* rec, /* in: case of an update or delete
  184. marking, the record in the clustered
  185. index, otherwise NULL */
  186. dulint* roll_ptr); /* out: rollback pointer to the
  187. inserted undo log record,
  188. ut_dulint_zero if BTR_NO_UNDO_LOG
  189. flag was specified */
  190. /**********************************************************************
  191. Copies an undo record to heap. This function can be called if we know that
  192. the undo log record exists. */
  193. trx_undo_rec_t*
  194. trx_undo_get_undo_rec_low(
  195. /*======================*/
  196. /* out, own: copy of the record */
  197. dulint roll_ptr, /* in: roll pointer to record */
  198. mem_heap_t* heap); /* in: memory heap where copied */
  199. /**********************************************************************
  200. Copies an undo record to heap. */
  201. ulint
  202. trx_undo_get_undo_rec(
  203. /*==================*/
  204. /* out: DB_SUCCESS, or
  205. DB_MISSING_HISTORY if the undo log
  206. has been truncated and we cannot
  207. fetch the old version; NOTE: the
  208. caller must have latches on the
  209. clustered index page and purge_view */
  210. dulint roll_ptr, /* in: roll pointer to record */
  211. dulint trx_id, /* in: id of the trx that generated
  212. the roll pointer: it points to an
  213. undo log of this transaction */
  214. trx_undo_rec_t** undo_rec, /* out, own: copy of the record */
  215. mem_heap_t* heap); /* in: memory heap where copied */
  216. /***********************************************************************
  217. Build a previous version of a clustered index record. This function checks
  218. that the caller has a latch on the index page of the clustered index record
  219. and an s-latch on the purge_view. This guarantees that the stack of versions
  220. is locked. */
  221. ulint
  222. trx_undo_prev_version_build(
  223. /*========================*/
  224. /* out: DB_SUCCESS, or DB_MISSING_HISTORY if
  225. the previous version is not >= purge_view,
  226. which means that it may have been removed,
  227. DB_ERROR if corrupted record */
  228. rec_t* index_rec,/* in: clustered index record in the
  229. index tree */
  230. mtr_t* index_mtr,/* in: mtr which contains the latch to
  231. index_rec page and purge_view */
  232. rec_t* rec, /* in: version of a clustered index record */
  233. dict_index_t* index, /* in: clustered index */
  234. mem_heap_t* heap, /* in: memory heap from which the memory
  235. needed is allocated */
  236. rec_t** old_vers);/* out, own: previous version, or NULL if
  237. rec is the first inserted version, or if
  238. history data has been deleted */
  239. /***************************************************************
  240. Parses a redo log record of adding an undo log record. */
  241. byte*
  242. trx_undo_parse_add_undo_rec(
  243. /*========================*/
  244. /* out: end of log record or NULL */
  245. byte* ptr, /* in: buffer */
  246. byte* end_ptr,/* in: buffer end */
  247. page_t* page); /* in: page or NULL */
  248. /***************************************************************
  249. Parses a redo log record of erasing of an undo page end. */
  250. byte*
  251. trx_undo_parse_erase_page_end(
  252. /*==========================*/
  253. /* out: end of log record or NULL */
  254. byte* ptr, /* in: buffer */
  255. byte* end_ptr,/* in: buffer end */
  256. page_t* page, /* in: page or NULL */
  257. mtr_t* mtr); /* in: mtr or NULL */
  258. /* Types of an undo log record: these have to be smaller than 16, as the
  259. compilation info multiplied by 16 is ORed to this value in an undo log
  260. record */
  261. #define TRX_UNDO_INSERT_REC 11 /* fresh insert into clustered index */
  262. #define TRX_UNDO_UPD_EXIST_REC 12 /* update of a non-delete-marked
  263. record */
  264. #define TRX_UNDO_UPD_DEL_REC 13 /* update of a delete marked record to
  265. a not delete marked record; also the
  266. fields of the record can change */
  267. #define TRX_UNDO_DEL_MARK_REC 14 /* delete marking of a record; fields
  268. do not change */
  269. #define TRX_UNDO_CMPL_INFO_MULT 16 /* compilation info is multiplied by
  270. this and ORed to the type above */
  271. #define TRX_UNDO_UPD_EXTERN 128 /* This bit can be ORed to type_cmpl
  272. to denote that we updated external
  273. storage fields: used by purge to
  274. free the external storage */
  275. /* Operation type flags used in trx_undo_report_row_operation */
  276. #define TRX_UNDO_INSERT_OP 1
  277. #define TRX_UNDO_MODIFY_OP 2
  278. #ifndef UNIV_NONINL
  279. #include "trx0rec.ic"
  280. #endif
  281. #endif