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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Row undo
  3. (c) 1997 Innobase Oy
  4. Created 1/8/1997 Heikki Tuuri
  5. *******************************************************/
  6. #include "row0undo.h"
  7. #ifdef UNIV_NONINL
  8. #include "row0undo.ic"
  9. #endif
  10. #include "fsp0fsp.h"
  11. #include "mach0data.h"
  12. #include "trx0rseg.h"
  13. #include "trx0trx.h"
  14. #include "trx0roll.h"
  15. #include "trx0undo.h"
  16. #include "trx0purge.h"
  17. #include "trx0rec.h"
  18. #include "que0que.h"
  19. #include "row0row.h"
  20. #include "row0uins.h"
  21. #include "row0umod.h"
  22. #include "row0mysql.h"
  23. #include "srv0srv.h"
  24. /* How to undo row operations?
  25. (1) For an insert, we have stored a prefix of the clustered index record
  26. in the undo log. Using it, we look for the clustered record, and using
  27. that we look for the records in the secondary indexes. The insert operation
  28. may have been left incomplete, if the database crashed, for example.
  29. We may have look at the trx id and roll ptr to make sure the record in the
  30. clustered index is really the one for which the undo log record was
  31. written. We can use the framework we get from the original insert op.
  32. (2) Delete marking: We can use the framework we get from the original
  33. delete mark op. We only have to check the trx id.
  34. (3) Update: This may be the most complicated. We have to use the framework
  35. we get from the original update op.
  36. What if the same trx repeatedly deletes and inserts an identical row.
  37. Then the row id changes and also roll ptr. What if the row id was not
  38. part of the ordering fields in the clustered index? Maybe we have to write
  39. it to undo log. Well, maybe not, because if we order the row id and trx id
  40. in descending order, then the only undeleted copy is the first in the
  41. index. Our searches in row operations always position the cursor before
  42. the first record in the result set. But, if there is no key defined for
  43. a table, then it would be desirable that row id is in ascending order.
  44. So, lets store row id in descending order only if it is not an ordering
  45. field in the clustered index.
  46. NOTE: Deletes and inserts may lead to situation where there are identical
  47. records in a secondary index. Is that a problem in the B-tree? Yes.
  48. Also updates can lead to this, unless trx id and roll ptr are included in
  49. ord fields.
  50. (1) Fix in clustered indexes: include row id, trx id, and roll ptr
  51. in node pointers of B-tree.
  52. (2) Fix in secondary indexes: include all fields in node pointers, and
  53. if an entry is inserted, check if it is equal to the right neighbor,
  54. in which case update the right neighbor: the neighbor must be delete
  55. marked, set it unmarked and write the trx id of the current transaction.
  56. What if the same trx repeatedly updates the same row, updating a secondary
  57. index field or not? Updating a clustered index ordering field?
  58. (1) If it does not update the secondary index and not the clustered index
  59. ord field. Then the secondary index record stays unchanged, but the
  60. trx id in the secondary index record may be smaller than in the clustered
  61. index record. This is no problem?
  62. (2) If it updates secondary index ord field but not clustered: then in
  63. secondary index there are delete marked records, which differ in an
  64. ord field. No problem.
  65. (3) Updates clustered ord field but not secondary, and secondary index
  66. is unique. Then the record in secondary index is just updated at the
  67. clustered ord field.
  68. (4)
  69. Problem with duplicate records:
  70. Fix 1: Add a trx op no field to all indexes. A problem: if a trx with a
  71. bigger trx id has inserted and delete marked a similar row, our trx inserts
  72. again a similar row, and a trx with an even bigger id delete marks it. Then
  73. the position of the row should change in the index if the trx id affects
  74. the alphabetical ordering.
  75. Fix 2: If an insert encounters a similar row marked deleted, we turn the
  76. insert into an 'update' of the row marked deleted. Then we must write undo
  77. info on the update. A problem: what if a purge operation tries to remove
  78. the delete marked row?
  79. We can think of the database row versions as a linked list which starts
  80. from the record in the clustered index, and is linked by roll ptrs
  81. through undo logs. The secondary index records are references which tell
  82. what kinds of records can be found in this linked list for a record
  83. in the clustered index.
  84. How to do the purge? A record can be removed from the clustered index
  85. if its linked list becomes empty, i.e., the row has been marked deleted
  86. and its roll ptr points to the record in the undo log we are going through,
  87. doing the purge. Similarly, during a rollback, a record can be removed
  88. if the stored roll ptr in the undo log points to a trx already (being) purged,
  89. or if the roll ptr is NULL, i.e., it was a fresh insert. */
  90. /************************************************************************
  91. Creates a row undo node to a query graph. */
  92. undo_node_t*
  93. row_undo_node_create(
  94. /*=================*/
  95. /* out, own: undo node */
  96. trx_t* trx, /* in: transaction */
  97. que_thr_t* parent, /* in: parent node, i.e., a thr node */
  98. mem_heap_t* heap) /* in: memory heap where created */
  99. {
  100. undo_node_t* undo;
  101. ut_ad(trx && parent && heap);
  102. undo = mem_heap_alloc(heap, sizeof(undo_node_t));
  103. undo->common.type = QUE_NODE_UNDO;
  104. undo->common.parent = parent;
  105. undo->state = UNDO_NODE_FETCH_NEXT;
  106. undo->trx = trx;
  107. btr_pcur_init(&(undo->pcur));
  108. undo->heap = mem_heap_create(256);
  109. return(undo);
  110. }
  111. /***************************************************************
  112. Looks for the clustered index record when node has the row reference.
  113. The pcur in node is used in the search. If found, stores the row to node,
  114. and stores the position of pcur, and detaches it. The pcur must be closed
  115. by the caller in any case. */
  116. ibool
  117. row_undo_search_clust_to_pcur(
  118. /*==========================*/
  119. /* out: TRUE if found; NOTE the node->pcur
  120. must be closed by the caller, regardless of
  121. the return value */
  122. undo_node_t* node) /* in: row undo node */
  123. {
  124. dict_index_t* clust_index;
  125. ibool found;
  126. mtr_t mtr;
  127. ibool ret;
  128. rec_t* rec;
  129. mtr_start(&mtr);
  130. clust_index = dict_table_get_first_index(node->table);
  131. found = row_search_on_row_ref(&(node->pcur), BTR_MODIFY_LEAF,
  132. node->table, node->ref, &mtr);
  133. rec = btr_pcur_get_rec(&(node->pcur));
  134. if (!found || 0 != ut_dulint_cmp(node->roll_ptr,
  135.     row_get_rec_roll_ptr(rec, clust_index))) {
  136. /* We must remove the reservation on the undo log record
  137. BEFORE releasing the latch on the clustered index page: this
  138. is to make sure that some thread will eventually undo the
  139. modification corresponding to node->roll_ptr. */
  140. /* fputs("--------------------undoing a previous versionn",
  141. stderr); */
  142.    
  143. ret = FALSE;
  144. } else {
  145. node->row = row_build(ROW_COPY_DATA, clust_index, rec,
  146. node->heap);
  147. btr_pcur_store_position(&(node->pcur), &mtr);
  148. ret = TRUE;
  149. }
  150. btr_pcur_commit_specify_mtr(&(node->pcur), &mtr);
  151. return(ret);
  152. }
  153. /***************************************************************
  154. Fetches an undo log record and does the undo for the recorded operation.
  155. If none left, or a partial rollback completed, returns control to the
  156. parent node, which is always a query thread node. */
  157. static
  158. ulint
  159. row_undo(
  160. /*=====*/
  161. /* out: DB_SUCCESS if operation successfully
  162. completed, else error code */
  163. undo_node_t* node, /* in: row undo node */
  164. que_thr_t* thr) /* in: query thread */
  165. {
  166. ulint err;
  167. trx_t* trx;
  168. dulint roll_ptr;
  169. ibool froze_data_dict = FALSE;
  170. ut_ad(node && thr);
  171. trx = node->trx;
  172. if (node->state == UNDO_NODE_FETCH_NEXT) {
  173. node->undo_rec = trx_roll_pop_top_rec_of_trx(trx,
  174. trx->roll_limit,
  175. &roll_ptr,
  176. node->heap);
  177. if (!node->undo_rec) {
  178. /* Rollback completed for this query thread */
  179. thr->run_node = que_node_get_parent(node);
  180. return(DB_SUCCESS);
  181. }
  182. node->roll_ptr = roll_ptr;
  183. node->undo_no = trx_undo_rec_get_undo_no(node->undo_rec);
  184. if (trx_undo_roll_ptr_is_insert(roll_ptr)) {
  185. node->state = UNDO_NODE_INSERT;
  186. } else {
  187. node->state = UNDO_NODE_MODIFY;
  188. }
  189. } else if (node->state == UNDO_NODE_PREV_VERS) {
  190. /* Undo should be done to the same clustered index record
  191. again in this same rollback, restoring the previous version */
  192. roll_ptr = node->new_roll_ptr;
  193. node->undo_rec = trx_undo_get_undo_rec_low(roll_ptr,
  194. node->heap);
  195. node->roll_ptr = roll_ptr;
  196. node->undo_no = trx_undo_rec_get_undo_no(node->undo_rec);
  197. if (trx_undo_roll_ptr_is_insert(roll_ptr)) {
  198. node->state = UNDO_NODE_INSERT;
  199. } else {
  200. node->state = UNDO_NODE_MODIFY;
  201. }
  202. }
  203. /* Prevent DROP TABLE etc. while we are rolling back this row.
  204.         If we are doing a TABLE CREATE or some other dictionary operation,
  205.         then we already have dict_operation_lock locked in x-mode. Do not
  206.         try to lock again in s-mode, because that would cause a hang. */
  207. if (trx->dict_operation_lock_mode == 0) {
  208.         
  209.         row_mysql_freeze_data_dictionary(trx);
  210.         froze_data_dict = TRUE;
  211. }
  212. if (node->state == UNDO_NODE_INSERT) {
  213. err = row_undo_ins(node);
  214. node->state = UNDO_NODE_FETCH_NEXT;
  215. } else {
  216. ut_ad(node->state == UNDO_NODE_MODIFY);
  217. err = row_undo_mod(node, thr);
  218. }
  219. if (froze_data_dict) {
  220.         row_mysql_unfreeze_data_dictionary(trx);
  221. }
  222. /* Do some cleanup */
  223. btr_pcur_close(&(node->pcur));
  224. mem_heap_empty(node->heap);
  225. thr->run_node = node;
  226. return(err);
  227. }
  228. /***************************************************************
  229. Undoes a row operation in a table. This is a high-level function used
  230. in SQL execution graphs. */
  231. que_thr_t*
  232. row_undo_step(
  233. /*==========*/
  234. /* out: query thread to run next or NULL */
  235. que_thr_t* thr) /* in: query thread */
  236. {
  237. ulint err;
  238. undo_node_t* node;
  239. trx_t* trx;
  240. ut_ad(thr);
  241. srv_activity_count++;
  242. trx = thr_get_trx(thr);
  243. node = thr->run_node;
  244. ut_ad(que_node_get_type(node) == QUE_NODE_UNDO);
  245. err = row_undo(node, thr);
  246. trx->error_state = err;
  247. if (err != DB_SUCCESS) {
  248. /* SQL error detected */
  249. fprintf(stderr, "InnoDB: Fatal error %lu in rollback.n",
  250. (ulong) err);
  251. if (err == DB_OUT_OF_FILE_SPACE) {
  252. fprintf(stderr,
  253. "InnoDB: Error 13 means out of tablespace.n"
  254. "InnoDB: Consider increasing your tablespace.n");
  255. exit(1);
  256. }
  257. ut_error;
  258. return(NULL);
  259. }
  260. return(thr);