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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Undo modify of a row
  3. (c) 1997 Innobase Oy
  4. Created 2/27/1997 Heikki Tuuri
  5. *******************************************************/
  6. #include "row0umod.h"
  7. #ifdef UNIV_NONINL
  8. #include "row0umod.ic"
  9. #endif
  10. #include "dict0dict.h"
  11. #include "dict0boot.h"
  12. #include "trx0undo.h"
  13. #include "trx0roll.h"
  14. #include "btr0btr.h"
  15. #include "mach0data.h"
  16. #include "row0undo.h"
  17. #include "row0vers.h"
  18. #include "trx0trx.h"
  19. #include "trx0rec.h"
  20. #include "row0row.h"
  21. #include "row0upd.h"
  22. #include "que0que.h"
  23. #include "log0log.h"
  24. /* Considerations on undoing a modify operation.
  25. (1) Undoing a delete marking: all index records should be found. Some of
  26. them may have delete mark already FALSE, if the delete mark operation was
  27. stopped underway, or if the undo operation ended prematurely because of a
  28. system crash.
  29. (2) Undoing an update of a delete unmarked record: the newer version of
  30. an updated secondary index entry should be removed if no prior version
  31. of the clustered index record requires its existence. Otherwise, it should
  32. be delete marked.
  33. (3) Undoing an update of a delete marked record. In this kind of update a
  34. delete marked clustered index record was delete unmarked and possibly also
  35. some of its fields were changed. Now, it is possible that the delete marked
  36. version has become obsolete at the time the undo is started. */
  37. /***************************************************************
  38. Checks if also the previous version of the clustered index record was
  39. modified or inserted by the same transaction, and its undo number is such
  40. that it should be undone in the same rollback. */
  41. UNIV_INLINE
  42. ibool
  43. row_undo_mod_undo_also_prev_vers(
  44. /*=============================*/
  45. /* out: TRUE if also previous modify or
  46. insert of this row should be undone */
  47.   undo_node_t* node, /* in: row undo node */
  48. que_thr_t* thr, /* in: query thread */
  49. dulint* undo_no)/* out: the undo number */
  50. {
  51. trx_undo_rec_t* undo_rec;
  52. ibool ret;
  53. trx_t* trx;
  54. UT_NOT_USED(thr);
  55. trx = node->trx;
  56. if (0 != ut_dulint_cmp(node->new_trx_id, trx->id)) {
  57. return(FALSE);
  58. }
  59. undo_rec = trx_undo_get_undo_rec_low(node->new_roll_ptr, node->heap);
  60. *undo_no = trx_undo_rec_get_undo_no(undo_rec);
  61. if (ut_dulint_cmp(trx->roll_limit, *undo_no) <= 0) {
  62. ret = TRUE;
  63. } else {
  64. ret = FALSE;
  65. }
  66. return(ret);
  67. }
  68. /***************************************************************
  69. Undoes a modify in a clustered index record. */
  70. static
  71. ulint
  72. row_undo_mod_clust_low(
  73. /*===================*/
  74. /* out: DB_SUCCESS, DB_FAIL, or error code:
  75. we may run out of file space */
  76. undo_node_t* node, /* in: row undo node */
  77. que_thr_t* thr, /* in: query thread */
  78. mtr_t* mtr, /* in: mtr */
  79. ulint mode) /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE */
  80. {
  81. big_rec_t* dummy_big_rec;
  82. btr_pcur_t* pcur;
  83. btr_cur_t* btr_cur;
  84. ulint err;
  85. ibool success;
  86. pcur = &(node->pcur);
  87. btr_cur = btr_pcur_get_btr_cur(pcur);
  88. success = btr_pcur_restore_position(mode, pcur, mtr);
  89. ut_ad(success);
  90. if (mode == BTR_MODIFY_LEAF) {
  91. err = btr_cur_optimistic_update(BTR_NO_LOCKING_FLAG
  92. | BTR_NO_UNDO_LOG_FLAG
  93. | BTR_KEEP_SYS_FLAG,
  94. btr_cur, node->update,
  95. node->cmpl_info, thr, mtr);
  96. } else {
  97. ut_ad(mode == BTR_MODIFY_TREE);
  98. err = btr_cur_pessimistic_update(BTR_NO_LOCKING_FLAG
  99. | BTR_NO_UNDO_LOG_FLAG
  100. | BTR_KEEP_SYS_FLAG,
  101. btr_cur, &dummy_big_rec, node->update,
  102. node->cmpl_info, thr, mtr);
  103. }
  104. return(err);
  105. }
  106. /***************************************************************
  107. Removes a clustered index record after undo if possible. */
  108. static
  109. ulint
  110. row_undo_mod_remove_clust_low(
  111. /*==========================*/
  112. /* out: DB_SUCCESS, DB_FAIL, or error code:
  113. we may run out of file space */
  114. undo_node_t* node, /* in: row undo node */
  115. que_thr_t* thr __attribute__((unused)), /* in: query thread */
  116. mtr_t* mtr, /* in: mtr */
  117. ulint mode) /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE */
  118. {
  119. btr_pcur_t* pcur;
  120. btr_cur_t* btr_cur;
  121. ulint err;
  122. ibool success;
  123. pcur = &(node->pcur);
  124. btr_cur = btr_pcur_get_btr_cur(pcur);
  125. success = btr_pcur_restore_position(mode, pcur, mtr);
  126. if (!success) {
  127. return(DB_SUCCESS);
  128. }
  129. /* Find out if we can remove the whole clustered index record */
  130. if (node->rec_type == TRX_UNDO_UPD_DEL_REC
  131.     && !row_vers_must_preserve_del_marked(node->new_trx_id, mtr)) {
  132. /* Ok, we can remove */
  133. } else {
  134. return(DB_SUCCESS);
  135. }
  136.     
  137. if (mode == BTR_MODIFY_LEAF) {
  138. success = btr_cur_optimistic_delete(btr_cur, mtr);
  139. if (success) {
  140. err = DB_SUCCESS;
  141. } else {
  142. err = DB_FAIL;
  143. }
  144. } else {
  145. ut_ad(mode == BTR_MODIFY_TREE);
  146. /* Note that since this operation is analogous to purge,
  147. we can free also inherited externally stored fields:
  148. hence the last FALSE in the call below */
  149. btr_cur_pessimistic_delete(&err, FALSE, btr_cur, FALSE, mtr);
  150. /* The delete operation may fail if we have little
  151. file space left: TODO: easiest to crash the database
  152. and restart with more file space */
  153. }
  154. return(err);
  155. }
  156. /***************************************************************
  157. Undoes a modify in a clustered index record. Sets also the node state for the
  158. next round of undo. */
  159. static
  160. ulint
  161. row_undo_mod_clust(
  162. /*===============*/
  163. /* out: DB_SUCCESS or error code: we may run
  164. out of file space */
  165. undo_node_t* node, /* in: row undo node */
  166. que_thr_t* thr) /* in: query thread */
  167. {
  168. btr_pcur_t* pcur;
  169. mtr_t mtr;
  170. ulint err;
  171. ibool success;
  172. ibool more_vers;
  173. dulint new_undo_no;
  174. ut_ad(node && thr);
  175. /* Check if also the previous version of the clustered index record
  176. should be undone in this same rollback operation */
  177. more_vers = row_undo_mod_undo_also_prev_vers(node, thr, &new_undo_no);
  178. pcur = &(node->pcur);
  179. mtr_start(&mtr);
  180. /* Try optimistic processing of the record, keeping changes within
  181. the index page */
  182. err = row_undo_mod_clust_low(node, thr, &mtr, BTR_MODIFY_LEAF);
  183. if (err != DB_SUCCESS) {
  184. btr_pcur_commit_specify_mtr(pcur, &mtr);
  185. /* We may have to modify tree structure: do a pessimistic
  186. descent down the index tree */
  187. mtr_start(&mtr);
  188. err = row_undo_mod_clust_low(node, thr, &mtr, BTR_MODIFY_TREE);
  189. }
  190. btr_pcur_commit_specify_mtr(pcur, &mtr);
  191. if (err == DB_SUCCESS && node->rec_type == TRX_UNDO_UPD_DEL_REC) {
  192. mtr_start(&mtr);
  193. err = row_undo_mod_remove_clust_low(node, thr, &mtr,
  194. BTR_MODIFY_LEAF);
  195. if (err != DB_SUCCESS) {
  196. btr_pcur_commit_specify_mtr(pcur, &mtr);
  197. /* We may have to modify tree structure: do a
  198. pessimistic descent down the index tree */
  199. mtr_start(&mtr);
  200. err = row_undo_mod_remove_clust_low(node, thr, &mtr,
  201. BTR_MODIFY_TREE);
  202. }
  203. btr_pcur_commit_specify_mtr(pcur, &mtr);
  204. }
  205. node->state = UNDO_NODE_FETCH_NEXT;
  206.   trx_undo_rec_release(node->trx, node->undo_no);
  207. if (more_vers && err == DB_SUCCESS) {
  208. /* Reserve the undo log record to the prior version after
  209. committing &mtr: this is necessary to comply with the latching
  210. order, as &mtr may contain the fsp latch which is lower in
  211. the latch hierarchy than trx->undo_mutex. */
  212. success = trx_undo_rec_reserve(node->trx, new_undo_no);
  213. if (success) {
  214. node->state = UNDO_NODE_PREV_VERS;
  215. }
  216. }
  217. return(err);
  218. }
  219. /***************************************************************
  220. Delete marks or removes a secondary index entry if found. */
  221. static
  222. ulint
  223. row_undo_mod_del_mark_or_remove_sec_low(
  224. /*====================================*/
  225. /* out: DB_SUCCESS, DB_FAIL, or
  226. DB_OUT_OF_FILE_SPACE */
  227. undo_node_t* node, /* in: row undo node */
  228. que_thr_t* thr, /* in: query thread */
  229. dict_index_t* index, /* in: index */
  230. dtuple_t* entry, /* in: index entry */
  231. ulint mode) /* in: latch mode BTR_MODIFY_LEAF or
  232. BTR_MODIFY_TREE */
  233. {
  234. ibool found;
  235. btr_pcur_t pcur;
  236. btr_cur_t* btr_cur;
  237. ibool success;
  238. ibool old_has;
  239. ulint err;
  240. mtr_t mtr;
  241. mtr_t mtr_vers;
  242. log_free_check();
  243. mtr_start(&mtr);
  244. found = row_search_index_entry(index, entry, mode, &pcur, &mtr);
  245. btr_cur = btr_pcur_get_btr_cur(&pcur);
  246. if (!found) {
  247. /* Not found */
  248. btr_pcur_close(&pcur);
  249. mtr_commit(&mtr);
  250. return(DB_SUCCESS);
  251. }
  252. /* We should remove the index record if no prior version of the row,
  253. which cannot be purged yet, requires its existence. If some requires,
  254. we should delete mark the record. */
  255. mtr_start(&mtr_vers);
  256. success = btr_pcur_restore_position(BTR_SEARCH_LEAF, &(node->pcur),
  257. &mtr_vers);
  258. ut_a(success);
  259. old_has = row_vers_old_has_index_entry(FALSE,
  260. btr_pcur_get_rec(&(node->pcur)),
  261. &mtr_vers, index, entry);
  262. if (old_has) {
  263. err = btr_cur_del_mark_set_sec_rec(BTR_NO_LOCKING_FLAG,
  264. btr_cur, TRUE, thr, &mtr);
  265. ut_ad(err == DB_SUCCESS);
  266. } else {
  267. /* Remove the index record */
  268. if (mode == BTR_MODIFY_LEAF) {
  269. success = btr_cur_optimistic_delete(btr_cur, &mtr);
  270. if (success) {
  271. err = DB_SUCCESS;
  272. } else {
  273. err = DB_FAIL;
  274. }
  275. } else {
  276. ut_ad(mode == BTR_MODIFY_TREE);
  277. btr_cur_pessimistic_delete(&err, FALSE, btr_cur,
  278. TRUE, &mtr);
  279. /* The delete operation may fail if we have little
  280. file space left: TODO: easiest to crash the database
  281. and restart with more file space */
  282. }
  283. }
  284. btr_pcur_commit_specify_mtr(&(node->pcur), &mtr_vers);
  285. btr_pcur_close(&pcur);
  286. mtr_commit(&mtr);
  287. return(err);
  288. }
  289. /***************************************************************
  290. Delete marks or removes a secondary index entry if found.
  291. NOTE that if we updated the fields of a delete-marked secondary index record
  292. so that alphabetically they stayed the same, e.g., 'abc' -> 'aBc', we cannot
  293. return to the original values because we do not know them. But this should
  294. not cause problems because in row0sel.c, in queries we always retrieve the
  295. clustered index record or an earlier version of it, if the secondary index
  296. record through which we do the search is delete-marked. */
  297. static
  298. ulint
  299. row_undo_mod_del_mark_or_remove_sec(
  300. /*================================*/
  301. /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
  302. undo_node_t* node, /* in: row undo node */
  303. que_thr_t* thr, /* in: query thread */
  304. dict_index_t* index, /* in: index */
  305. dtuple_t* entry) /* in: index entry */
  306. {
  307. ulint err;
  308. err = row_undo_mod_del_mark_or_remove_sec_low(node, thr, index,
  309.   entry, BTR_MODIFY_LEAF);
  310. if (err == DB_SUCCESS) {
  311. return(err);
  312. }
  313. err = row_undo_mod_del_mark_or_remove_sec_low(node, thr, index,
  314.   entry, BTR_MODIFY_TREE);
  315.   return(err);
  316. }
  317. /***************************************************************
  318. Delete unmarks a secondary index entry which must be found. It might not be
  319. delete-marked at the moment, but it does not harm to unmark it anyway. We also
  320. need to update the fields of the secondary index record if we updated its
  321. fields but alphabetically they stayed the same, e.g., 'abc' -> 'aBc'. */
  322. static
  323. ulint
  324. row_undo_mod_del_unmark_sec_and_undo_update(
  325. /*========================================*/
  326. /* out: DB_FAIL or DB_SUCCESS or
  327. DB_OUT_OF_FILE_SPACE */
  328. ulint mode, /* in: search mode: BTR_MODIFY_LEAF or
  329. BTR_MODIFY_TREE */
  330. que_thr_t* thr, /* in: query thread */
  331. dict_index_t* index, /* in: index */
  332. dtuple_t* entry) /* in: index entry */
  333. {
  334. mem_heap_t* heap;
  335. btr_pcur_t pcur;
  336. upd_t* update;
  337. ulint err = DB_SUCCESS;
  338. ibool found;
  339. big_rec_t* dummy_big_rec;
  340. mtr_t mtr;
  341. trx_t* trx = thr_get_trx(thr);
  342. log_free_check();
  343. mtr_start(&mtr);
  344. found = row_search_index_entry(index, entry, mode, &pcur, &mtr);
  345. if (!found) {
  346. fputs("InnoDB: error in sec index entry del undo inn"
  347. "InnoDB: ", stderr);
  348. dict_index_name_print(stderr, trx, index);
  349. fputs("n"
  350. "InnoDB: tuple ", stderr);
  351. dtuple_print(stderr, entry);
  352. fputs("n"
  353. "InnoDB: record ", stderr);
  354. rec_print(stderr, btr_pcur_get_rec(&pcur));
  355. putc('n', stderr);
  356. trx_print(stderr, trx);
  357. fputs("n"
  358. "InnoDB: Submit a detailed bug report to http://bugs.mysql.comn", stderr);
  359. } else {
  360. btr_cur_t* btr_cur = btr_pcur_get_btr_cur(&pcur);
  361.         err = btr_cur_del_mark_set_sec_rec(BTR_NO_LOCKING_FLAG,
  362. btr_cur, FALSE, thr, &mtr);
  363.         ut_a(err == DB_SUCCESS);
  364. heap = mem_heap_create(100);
  365. update = row_upd_build_sec_rec_difference_binary(index, entry,
  366. btr_cur_get_rec(btr_cur), trx, heap);
  367.         if (upd_get_n_fields(update) == 0) {
  368. /* Do nothing */
  369. } else if (mode == BTR_MODIFY_LEAF) {
  370.                  /* Try an optimistic updating of the record, keeping
  371. changes within the page */
  372.                  err = btr_cur_optimistic_update(BTR_KEEP_SYS_FLAG
  373. | BTR_NO_LOCKING_FLAG,
  374.   btr_cur, update, 0, thr, &mtr);
  375.                  if (err == DB_OVERFLOW || err == DB_UNDERFLOW) {
  376.                          err = DB_FAIL;
  377.                  }
  378.         } else  {
  379.                  ut_a(mode == BTR_MODIFY_TREE);
  380.                  err = btr_cur_pessimistic_update(BTR_KEEP_SYS_FLAG
  381. | BTR_NO_LOCKING_FLAG,
  382. btr_cur, &dummy_big_rec,
  383. update, 0, thr, &mtr);
  384.          }
  385. mem_heap_free(heap);
  386. }
  387. btr_pcur_close(&pcur);
  388. mtr_commit(&mtr);
  389. return(err);
  390. }
  391. /***************************************************************
  392. Undoes a modify in secondary indexes when undo record type is UPD_DEL. */
  393. static
  394. ulint
  395. row_undo_mod_upd_del_sec(
  396. /*=====================*/
  397. /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
  398. undo_node_t* node, /* in: row undo node */
  399. que_thr_t* thr) /* in: query thread */
  400. {
  401. mem_heap_t* heap;
  402. dtuple_t* entry;
  403. dict_index_t* index;
  404. ulint err;
  405. heap = mem_heap_create(1024);
  406. while (node->index != NULL) {
  407. index = node->index;
  408. entry = row_build_index_entry(node->row, index, heap);
  409. err = row_undo_mod_del_mark_or_remove_sec(node, thr, index,
  410. entry);
  411. if (err != DB_SUCCESS) {
  412. mem_heap_free(heap);
  413. return(err);
  414. }
  415. node->index = dict_table_get_next_index(node->index);
  416. }
  417. mem_heap_free(heap);
  418. return(DB_SUCCESS);
  419. }
  420. /***************************************************************
  421. Undoes a modify in secondary indexes when undo record type is DEL_MARK. */
  422. static
  423. ulint
  424. row_undo_mod_del_mark_sec(
  425. /*======================*/
  426. /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
  427. undo_node_t* node, /* in: row undo node */
  428. que_thr_t* thr) /* in: query thread */
  429. {
  430. mem_heap_t* heap;
  431. dtuple_t* entry;
  432. dict_index_t* index;
  433. ulint err;
  434. heap = mem_heap_create(1024);
  435. while (node->index != NULL) {
  436. index = node->index;
  437. entry = row_build_index_entry(node->row, index, heap);
  438. err = row_undo_mod_del_unmark_sec_and_undo_update(
  439. BTR_MODIFY_LEAF,
  440. thr, index, entry);
  441. if (err == DB_FAIL) {
  442. err = row_undo_mod_del_unmark_sec_and_undo_update(
  443. BTR_MODIFY_TREE,
  444. thr, index, entry);
  445. }
  446. if (err != DB_SUCCESS) {
  447. mem_heap_free(heap);
  448. return(err);
  449. }
  450. node->index = dict_table_get_next_index(node->index);
  451. }
  452. mem_heap_free(heap);
  453. return(DB_SUCCESS);
  454. }
  455. /***************************************************************
  456. Undoes a modify in secondary indexes when undo record type is UPD_EXIST. */
  457. static
  458. ulint
  459. row_undo_mod_upd_exist_sec(
  460. /*=======================*/
  461. /* out: DB_SUCCESS or DB_OUT_OF_FILE_SPACE */
  462. undo_node_t* node, /* in: row undo node */
  463. que_thr_t* thr) /* in: query thread */
  464. {
  465. mem_heap_t* heap;
  466. dtuple_t* entry;
  467. dict_index_t* index;
  468. ulint err;
  469. if (node->cmpl_info & UPD_NODE_NO_ORD_CHANGE) {
  470. /* No change in secondary indexes */
  471. return(DB_SUCCESS);
  472. }
  473. heap = mem_heap_create(1024);
  474. while (node->index != NULL) {
  475. index = node->index;
  476. if (row_upd_changes_ord_field_binary(node->row, node->index,
  477. node->update)) {
  478. /* Build the newest version of the index entry */
  479. entry = row_build_index_entry(node->row, index, heap);
  480. /* NOTE that if we updated the fields of a
  481. delete-marked secondary index record so that
  482. alphabetically they stayed the same, e.g.,
  483. 'abc' -> 'aBc', we cannot return to the original
  484. values because we do not know them. But this should
  485. not cause problems because in row0sel.c, in queries
  486. we always retrieve the clustered index record or an
  487. earlier version of it, if the secondary index record
  488. through which we do the search is delete-marked. */
  489. err = row_undo_mod_del_mark_or_remove_sec(node, thr,
  490. index, entry);
  491. if (err != DB_SUCCESS) {
  492. mem_heap_free(heap);
  493. return(err);
  494. }
  495. /* We may have to update the delete mark in the
  496. secondary index record of the previous version of
  497. the row. We also need to update the fields of
  498. the secondary index record if we updated its fields
  499. but alphabetically they stayed the same, e.g.,
  500. 'abc' -> 'aBc'. */
  501. row_upd_index_replace_new_col_vals(entry, index,
  502. node->update, NULL);
  503. err = row_undo_mod_del_unmark_sec_and_undo_update(
  504. BTR_MODIFY_LEAF,
  505. thr, index, entry);
  506. if (err == DB_FAIL) {
  507. err =
  508.    row_undo_mod_del_unmark_sec_and_undo_update(
  509. BTR_MODIFY_TREE,
  510. thr, index, entry);
  511. }
  512. if (err != DB_SUCCESS) {
  513. mem_heap_free(heap);
  514. return(err);
  515. }
  516. }
  517. node->index = dict_table_get_next_index(node->index);
  518. }
  519. mem_heap_free(heap);
  520. return(DB_SUCCESS);
  521. }
  522. /***************************************************************
  523. Parses the row reference and other info in a modify undo log record. */
  524. static
  525. void
  526. row_undo_mod_parse_undo_rec(
  527. /*========================*/
  528. undo_node_t* node, /* in: row undo node */
  529. que_thr_t* thr) /* in: query thread */
  530. {
  531. dict_index_t* clust_index;
  532. byte* ptr;
  533. dulint undo_no;
  534. dulint table_id;
  535. dulint trx_id;
  536. dulint roll_ptr;
  537. ulint info_bits;
  538. ulint type;
  539. ulint cmpl_info;
  540. ibool dummy_extern;
  541. trx_t* trx;
  542. ut_ad(node && thr);
  543. trx = thr_get_trx(thr);
  544. ptr = trx_undo_rec_get_pars(node->undo_rec, &type, &cmpl_info,
  545. &dummy_extern, &undo_no, &table_id);
  546. node->rec_type = type;
  547. node->table = dict_table_get_on_id(table_id, trx);
  548. /* TODO: other fixes associated with DROP TABLE + rollback in the
  549. same table by another user */
  550. if (node->table == NULL) {
  551.         /* Table was dropped */
  552.         return;
  553. }
  554. if (node->table->ibd_file_missing) {
  555. /* We skip undo operations to missing .ibd files */
  556. node->table = NULL;
  557. return;
  558. }
  559. clust_index = dict_table_get_first_index(node->table);
  560. ptr = trx_undo_update_rec_get_sys_cols(ptr, &trx_id, &roll_ptr,
  561. &info_bits);
  562. ptr = trx_undo_rec_get_row_ref(ptr, clust_index, &(node->ref),
  563. node->heap);
  564. trx_undo_update_rec_get_update(ptr, clust_index, type, trx_id,
  565. roll_ptr, info_bits, trx,
  566. node->heap, &(node->update));
  567. node->new_roll_ptr = roll_ptr;
  568. node->new_trx_id = trx_id;
  569. node->cmpl_info = cmpl_info;
  570. }
  571. /***************************************************************
  572. Undoes a modify operation on a row of a table. */
  573. ulint
  574. row_undo_mod(
  575. /*=========*/
  576. /* out: DB_SUCCESS or error code */
  577. undo_node_t* node, /* in: row undo node */
  578. que_thr_t* thr) /* in: query thread */
  579. {
  580. ibool found;
  581. ulint err;
  582. ut_ad(node && thr);
  583. ut_ad(node->state == UNDO_NODE_MODIFY);
  584. row_undo_mod_parse_undo_rec(node, thr);
  585. if (node->table == NULL) {
  586. found = FALSE;
  587. } else {
  588. found = row_undo_search_clust_to_pcur(node);
  589. }
  590. if (!found) {
  591. /* It is already undone, or will be undone by another query
  592. thread, or table was dropped */
  593.         trx_undo_rec_release(node->trx, node->undo_no);
  594. node->state = UNDO_NODE_FETCH_NEXT;
  595. return(DB_SUCCESS);
  596. }
  597. node->index = dict_table_get_next_index(
  598. dict_table_get_first_index(node->table));
  599. if (node->rec_type == TRX_UNDO_UPD_EXIST_REC) {
  600. err = row_undo_mod_upd_exist_sec(node, thr);
  601. } else if (node->rec_type == TRX_UNDO_DEL_MARK_REC) {
  602. err = row_undo_mod_del_mark_sec(node, thr);
  603. } else {
  604. ut_ad(node->rec_type == TRX_UNDO_UPD_DEL_REC);
  605. err = row_undo_mod_upd_del_sec(node, thr);
  606. }
  607. if (err != DB_SUCCESS) {
  608. return(err);
  609. }
  610. err = row_undo_mod_clust(node, thr);
  611. return(err);
  612. }