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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Row versions
  3. (c) 1997 Innobase Oy
  4. Created 2/6/1997 Heikki Tuuri
  5. *******************************************************/
  6. #include "row0vers.h"
  7. #ifdef UNIV_NONINL
  8. #include "row0vers.ic"
  9. #endif
  10. #include "dict0dict.h"
  11. #include "dict0boot.h"
  12. #include "btr0btr.h"
  13. #include "mach0data.h"
  14. #include "trx0rseg.h"
  15. #include "trx0trx.h"
  16. #include "trx0roll.h"
  17. #include "trx0undo.h"
  18. #include "trx0purge.h"
  19. #include "trx0rec.h"
  20. #include "que0que.h"
  21. #include "row0row.h"
  22. #include "row0upd.h"
  23. #include "rem0cmp.h"
  24. #include "read0read.h"
  25. #include "lock0lock.h"
  26. /*********************************************************************
  27. Finds out if an active transaction has inserted or modified a secondary
  28. index record. NOTE: the kernel mutex is temporarily released in this
  29. function! */
  30. trx_t*
  31. row_vers_impl_x_locked_off_kernel(
  32. /*==============================*/
  33. /* out: NULL if committed, else the active
  34. transaction; NOTE that the kernel mutex is
  35. temporarily released! */
  36. rec_t* rec, /* in: record in a secondary index */
  37. dict_index_t* index) /* in: the secondary index */
  38. {
  39. dict_index_t* clust_index;
  40. rec_t* clust_rec;
  41. rec_t* version;
  42. rec_t* prev_version;
  43. dulint trx_id;
  44. dulint prev_trx_id;
  45. mem_heap_t* heap;
  46. mem_heap_t* heap2;
  47. dtuple_t* row;
  48. dtuple_t* entry = NULL; /* assignment to eliminate compiler
  49. warning */
  50. trx_t* trx;
  51. ibool vers_del;
  52. ibool rec_del;
  53. ulint err;
  54. mtr_t mtr;
  55. #ifdef UNIV_SYNC_DEBUG
  56. ut_ad(mutex_own(&kernel_mutex));
  57. ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
  58. #endif /* UNIV_SYNC_DEBUG */
  59. mutex_exit(&kernel_mutex);
  60. mtr_start(&mtr);
  61. /* Search for the clustered index record: this is a time-consuming
  62. operation: therefore we release the kernel mutex; also, the release
  63. is required by the latching order convention. The latch on the
  64. clustered index locks the top of the stack of versions. We also
  65. reserve purge_latch to lock the bottom of the version stack. */
  66. clust_rec = row_get_clust_rec(BTR_SEARCH_LEAF, rec, index,
  67. &clust_index, &mtr);
  68. if (!clust_rec) {
  69. /* In a rare case it is possible that no clust rec is found
  70. for a secondary index record: if in row0umod.c
  71. row_undo_mod_remove_clust_low() we have already removed the
  72. clust rec, while purge is still cleaning and removing
  73. secondary index records associated with earlier versions of
  74. the clustered index record. In that case there cannot be
  75. any implicit lock on the secondary index record, because
  76. an active transaction which has modified the secondary index
  77. record has also modified the clustered index record. And in
  78. a rollback we always undo the modifications to secondary index
  79. records before the clustered index record. */
  80. mutex_enter(&kernel_mutex);
  81. mtr_commit(&mtr);
  82.         return(NULL);
  83. }
  84. trx_id = row_get_rec_trx_id(clust_rec, clust_index);
  85. mtr_s_lock(&(purge_sys->latch), &mtr);
  86. mutex_enter(&kernel_mutex);
  87. if (!trx_is_active(trx_id)) {
  88. /* The transaction that modified or inserted clust_rec is no
  89. longer active: no implicit lock on rec */
  90. mtr_commit(&mtr);
  91. return(NULL);
  92. }
  93. if (!lock_check_trx_id_sanity(trx_id, clust_rec, clust_index, TRUE)) {
  94. /* Corruption noticed: try to avoid a crash by returning */
  95. mtr_commit(&mtr);
  96. return(NULL);
  97. }
  98. /* We look up if some earlier version, which was modified by the trx_id
  99. transaction, of the clustered index record would require rec to be in
  100. a different state (delete marked or unmarked, or have different field
  101. values, or not existing). If there is such a version, then rec was
  102. modified by the trx_id transaction, and it has an implicit x-lock on
  103. rec. Note that if clust_rec itself would require rec to be in a
  104. different state, then the trx_id transaction has not yet had time to
  105. modify rec, and does not necessarily have an implicit x-lock on rec. */
  106. rec_del = rec_get_deleted_flag(rec);
  107. trx = NULL;
  108. version = clust_rec;
  109. heap = NULL;
  110. for (;;) {
  111. mutex_exit(&kernel_mutex);
  112. /* While we retrieve an earlier version of clust_rec, we
  113. release the kernel mutex, because it may take time to access
  114. the disk. After the release, we have to check if the trx_id
  115. transaction is still active. We keep the semaphore in mtr on
  116. the clust_rec page, so that no other transaction can update
  117. it and get an implicit x-lock on rec. */
  118. heap2 = heap;
  119. heap = mem_heap_create(1024);
  120. err = trx_undo_prev_version_build(clust_rec, &mtr, version,
  121. clust_index, heap,
  122. &prev_version);
  123. if (heap2) {
  124. mem_heap_free(heap2); /* version was stored in heap2,
  125. if heap2 != NULL */
  126. }
  127. if (prev_version) {
  128. row = row_build(ROW_COPY_POINTERS, clust_index,
  129. prev_version, heap);
  130. entry = row_build_index_entry(row, index, heap);
  131. }
  132. mutex_enter(&kernel_mutex);
  133. if (!trx_is_active(trx_id)) {
  134. /* Transaction no longer active: no implicit x-lock */
  135. break;
  136. }
  137. /* If the transaction is still active, the previous version
  138. of clust_rec must be accessible if not a fresh insert; we
  139. may assert the following: */
  140. ut_ad(err == DB_SUCCESS);
  141. if (prev_version == NULL) {
  142. /* It was a freshly inserted version: there is an
  143. implicit x-lock on rec */
  144. trx = trx_get_on_id(trx_id);
  145. break;
  146. }
  147. /* If we get here, we know that the trx_id transaction is
  148. still active and it has modified prev_version. Let us check
  149. if prev_version would require rec to be in a different
  150. state. */
  151. vers_del = rec_get_deleted_flag(prev_version);
  152. /* We check if entry and rec are identified in the alphabetical
  153. ordering */
  154. if (0 == cmp_dtuple_rec(entry, rec)) {
  155. /* The delete marks of rec and prev_version should be
  156. equal for rec to be in the state required by
  157. prev_version */
  158. if (rec_del != vers_del) {
  159. trx = trx_get_on_id(trx_id);
  160. break;
  161. }
  162. /* It is possible that the row was updated so that the
  163. secondary index record remained the same in
  164. alphabetical ordering, but the field values changed
  165. still. For example, 'abc' -> 'ABC'. Check also that. */
  166. dtuple_set_types_binary(entry,
  167. dtuple_get_n_fields(entry));
  168. if (0 != cmp_dtuple_rec(entry, rec)) {
  169. trx = trx_get_on_id(trx_id);
  170. break;
  171. }
  172. } else if (!rec_del) {
  173. /* The delete mark should be set in rec for it to be
  174. in the state required by prev_version */
  175. trx = trx_get_on_id(trx_id);
  176. break;
  177. }
  178. prev_trx_id = row_get_rec_trx_id(prev_version, clust_index);
  179. if (0 != ut_dulint_cmp(trx_id, prev_trx_id)) {
  180. /* The versions modified by the trx_id transaction end
  181. to prev_version: no implicit x-lock */
  182. break;
  183. }
  184. version = prev_version;
  185. }/* for (;;) */
  186. mtr_commit(&mtr);
  187. mem_heap_free(heap);
  188. return(trx);
  189. }
  190. /*********************************************************************
  191. Finds out if we must preserve a delete marked earlier version of a clustered
  192. index record, because it is >= the purge view. */
  193. ibool
  194. row_vers_must_preserve_del_marked(
  195. /*==============================*/
  196. /* out: TRUE if earlier version should be preserved */
  197. dulint trx_id, /* in: transaction id in the version */
  198. mtr_t* mtr) /* in: mtr holding the latch on the clustered index
  199. record; it will also hold the latch on purge_view */
  200. {
  201. #ifdef UNIV_SYNC_DEBUG
  202. ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
  203. #endif /* UNIV_SYNC_DEBUG */
  204. mtr_s_lock(&(purge_sys->latch), mtr);
  205. if (trx_purge_update_undo_must_exist(trx_id)) {
  206. /* A purge operation is not yet allowed to remove this
  207. delete marked record */
  208. return(TRUE);
  209. }
  210. return(FALSE);
  211. }
  212. /*********************************************************************
  213. Finds out if a version of the record, where the version >= the current
  214. purge view, should have ientry as its secondary index entry. We check
  215. if there is any not delete marked version of the record where the trx
  216. id >= purge view, and the secondary index entry and ientry are identified in
  217. the alphabetical ordering; exactly in this case we return TRUE. */
  218. ibool
  219. row_vers_old_has_index_entry(
  220. /*=========================*/
  221. /* out: TRUE if earlier version should have */
  222. ibool also_curr,/* in: TRUE if also rec is included in the
  223. versions to search; otherwise only versions
  224. prior to it are searched */
  225. rec_t* rec, /* in: record in the clustered index; the
  226. caller must have a latch on the page */
  227. mtr_t* mtr, /* in: mtr holding the latch on rec; it will
  228. also hold the latch on purge_view */
  229. dict_index_t* index, /* in: the secondary index */
  230. dtuple_t* ientry) /* in: the secondary index entry */
  231. {
  232. rec_t* version;
  233. rec_t* prev_version;
  234. dict_index_t* clust_index;
  235. mem_heap_t* heap;
  236. mem_heap_t* heap2;
  237. dtuple_t* row;
  238. dtuple_t* entry;
  239. ulint err;
  240. ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_X_FIX)
  241.     || mtr_memo_contains(mtr, buf_block_align(rec),
  242. MTR_MEMO_PAGE_S_FIX));
  243. #ifdef UNIV_SYNC_DEBUG
  244. ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
  245. #endif /* UNIV_SYNC_DEBUG */
  246. mtr_s_lock(&(purge_sys->latch), mtr);
  247. clust_index = dict_table_get_first_index(index->table);
  248. if (also_curr && !rec_get_deleted_flag(rec)) {
  249. heap = mem_heap_create(1024);
  250. row = row_build(ROW_COPY_POINTERS, clust_index, rec, heap);
  251. entry = row_build_index_entry(row, index, heap);
  252.   /* NOTE that we cannot do the comparison as binary
  253. fields because the row is maybe being modified so that
  254. the clustered index record has already been updated
  255. to a different binary value in a char field, but the
  256. collation identifies the old and new value anyway! */
  257. if (dtuple_datas_are_ordering_equal(ientry, entry)) {
  258. mem_heap_free(heap);
  259. return(TRUE);
  260. }
  261. mem_heap_free(heap);
  262. }
  263. version = rec;
  264. heap = NULL;
  265. for (;;) {
  266. heap2 = heap;
  267. heap = mem_heap_create(1024);
  268. err = trx_undo_prev_version_build(rec, mtr, version,
  269. clust_index, heap,
  270. &prev_version);
  271. if (heap2) {
  272. mem_heap_free(heap2); /* version was stored in heap2,
  273. if heap2 != NULL */
  274. }
  275. if (err != DB_SUCCESS || !prev_version) {
  276. /* Versions end here */
  277. mem_heap_free(heap);
  278. return(FALSE);
  279. }
  280. if (!rec_get_deleted_flag(prev_version)) {
  281. row = row_build(ROW_COPY_POINTERS, clust_index,
  282. prev_version, heap);
  283. entry = row_build_index_entry(row, index, heap);
  284.   /* NOTE that we cannot do the comparison as binary
  285. fields because maybe the secondary index record has
  286. already been updated to a different binary value in
  287. a char field, but the collation identifies the old
  288. and new value anyway! */
  289. if (dtuple_datas_are_ordering_equal(ientry, entry)) {
  290. mem_heap_free(heap);
  291. return(TRUE);
  292. }
  293. }
  294. version = prev_version;
  295. }
  296. }
  297. /*********************************************************************
  298. Constructs the version of a clustered index record which a consistent
  299. read should see. We assume that the trx id stored in rec is such that
  300. the consistent read should not see rec in its present version. */
  301. ulint
  302. row_vers_build_for_consistent_read(
  303. /*===============================*/
  304. /* out: DB_SUCCESS or DB_MISSING_HISTORY */
  305. rec_t* rec, /* in: record in a clustered index; the
  306. caller must have a latch on the page; this
  307. latch locks the top of the stack of versions
  308. of this records */
  309. mtr_t* mtr, /* in: mtr holding the latch on rec */
  310. dict_index_t* index, /* in: the clustered index */
  311. read_view_t* view, /* in: the consistent read view */
  312. mem_heap_t* in_heap,/* in: memory heap from which the memory for
  313. old_vers is allocated; memory for possible
  314. intermediate versions is allocated and freed
  315. locally within the function */
  316. rec_t** old_vers)/* out, own: old version, or NULL if the
  317. record does not exist in the view, that is,
  318. it was freshly inserted afterwards */
  319. {
  320. rec_t* version;
  321. rec_t* prev_version;
  322. dulint prev_trx_id;
  323. mem_heap_t* heap;
  324. mem_heap_t* heap2;
  325. byte* buf;
  326. ulint err;
  327. ut_ad(index->type & DICT_CLUSTERED);
  328. ut_ad(mtr_memo_contains(mtr, buf_block_align(rec), MTR_MEMO_PAGE_X_FIX)
  329.     || mtr_memo_contains(mtr, buf_block_align(rec),
  330. MTR_MEMO_PAGE_S_FIX));
  331. #ifdef UNIV_SYNC_DEBUG
  332. ut_ad(!rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
  333. #endif /* UNIV_SYNC_DEBUG */
  334. ut_ad(!read_view_sees_trx_id(view, row_get_rec_trx_id(rec, index)));
  335. rw_lock_s_lock(&(purge_sys->latch));
  336. version = rec;
  337. heap = NULL;
  338. for (;;) {
  339. heap2 = heap;
  340. heap = mem_heap_create(1024);
  341. err = trx_undo_prev_version_build(rec, mtr, version, index,
  342. heap, &prev_version);
  343. if (heap2) {
  344. mem_heap_free(heap2); /* version was stored in heap2,
  345. if heap2 != NULL */
  346. }
  347. if (err != DB_SUCCESS) {
  348. break;
  349. }
  350. if (prev_version == NULL) {
  351. /* It was a freshly inserted version */
  352. *old_vers = NULL;
  353. err = DB_SUCCESS;
  354. break;
  355. }
  356. prev_trx_id = row_get_rec_trx_id(prev_version, index);
  357. if (read_view_sees_trx_id(view, prev_trx_id)) {
  358. /* The view already sees this version: we can copy
  359. it to in_heap and return */
  360. buf = mem_heap_alloc(in_heap, rec_get_size(
  361. prev_version));
  362. *old_vers = rec_copy(buf, prev_version);
  363. err = DB_SUCCESS;
  364. break;
  365. }
  366. version = prev_version;
  367. }/* for (;;) */
  368. mem_heap_free(heap);
  369. rw_lock_s_unlock(&(purge_sys->latch));
  370. return(err);
  371. }