Drizzled Public API Documentation

row0undo.cc
1 /*****************************************************************************
2 
3 Copyright (C) 1997, 2009, Innobase Oy. All Rights Reserved.
4 
5 This program is free software; you can redistribute it and/or modify it under
6 the terms of the GNU General Public License as published by the Free Software
7 Foundation; version 2 of the License.
8 
9 This program is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12 
13 You should have received a copy of the GNU General Public License along with
14 this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15 St, Fifth Floor, Boston, MA 02110-1301 USA
16 
17 *****************************************************************************/
18 
19 /**************************************************/
26 #include "row0undo.h"
27 
28 #ifdef UNIV_NONINL
29 #include "row0undo.ic"
30 #endif
31 
32 #include "fsp0fsp.h"
33 #include "mach0data.h"
34 #include "trx0rseg.h"
35 #include "trx0trx.h"
36 #include "trx0roll.h"
37 #include "trx0undo.h"
38 #include "trx0purge.h"
39 #include "trx0rec.h"
40 #include "que0que.h"
41 #include "row0row.h"
42 #include "row0uins.h"
43 #include "row0umod.h"
44 #include "row0upd.h"
45 #include "row0mysql.h"
46 #include "srv0srv.h"
47 
48 /* How to undo row operations?
49 (1) For an insert, we have stored a prefix of the clustered index record
50 in the undo log. Using it, we look for the clustered record, and using
51 that we look for the records in the secondary indexes. The insert operation
52 may have been left incomplete, if the database crashed, for example.
53 We may have look at the trx id and roll ptr to make sure the record in the
54 clustered index is really the one for which the undo log record was
55 written. We can use the framework we get from the original insert op.
56 (2) Delete marking: We can use the framework we get from the original
57 delete mark op. We only have to check the trx id.
58 (3) Update: This may be the most complicated. We have to use the framework
59 we get from the original update op.
60 
61 What if the same trx repeatedly deletes and inserts an identical row.
62 Then the row id changes and also roll ptr. What if the row id was not
63 part of the ordering fields in the clustered index? Maybe we have to write
64 it to undo log. Well, maybe not, because if we order the row id and trx id
65 in descending order, then the only undeleted copy is the first in the
66 index. Our searches in row operations always position the cursor before
67 the first record in the result set. But, if there is no key defined for
68 a table, then it would be desirable that row id is in ascending order.
69 So, lets store row id in descending order only if it is not an ordering
70 field in the clustered index.
71 
72 NOTE: Deletes and inserts may lead to situation where there are identical
73 records in a secondary index. Is that a problem in the B-tree? Yes.
74 Also updates can lead to this, unless trx id and roll ptr are included in
75 ord fields.
76 (1) Fix in clustered indexes: include row id, trx id, and roll ptr
77 in node pointers of B-tree.
78 (2) Fix in secondary indexes: include all fields in node pointers, and
79 if an entry is inserted, check if it is equal to the right neighbor,
80 in which case update the right neighbor: the neighbor must be delete
81 marked, set it unmarked and write the trx id of the current transaction.
82 
83 What if the same trx repeatedly updates the same row, updating a secondary
84 index field or not? Updating a clustered index ordering field?
85 
86 (1) If it does not update the secondary index and not the clustered index
87 ord field. Then the secondary index record stays unchanged, but the
88 trx id in the secondary index record may be smaller than in the clustered
89 index record. This is no problem?
90 (2) If it updates secondary index ord field but not clustered: then in
91 secondary index there are delete marked records, which differ in an
92 ord field. No problem.
93 (3) Updates clustered ord field but not secondary, and secondary index
94 is unique. Then the record in secondary index is just updated at the
95 clustered ord field.
96 (4)
97 
98 Problem with duplicate records:
99 Fix 1: Add a trx op no field to all indexes. A problem: if a trx with a
100 bigger trx id has inserted and delete marked a similar row, our trx inserts
101 again a similar row, and a trx with an even bigger id delete marks it. Then
102 the position of the row should change in the index if the trx id affects
103 the alphabetical ordering.
104 
105 Fix 2: If an insert encounters a similar row marked deleted, we turn the
106 insert into an 'update' of the row marked deleted. Then we must write undo
107 info on the update. A problem: what if a purge operation tries to remove
108 the delete marked row?
109 
110 We can think of the database row versions as a linked list which starts
111 from the record in the clustered index, and is linked by roll ptrs
112 through undo logs. The secondary index records are references which tell
113 what kinds of records can be found in this linked list for a record
114 in the clustered index.
115 
116 How to do the purge? A record can be removed from the clustered index
117 if its linked list becomes empty, i.e., the row has been marked deleted
118 and its roll ptr points to the record in the undo log we are going through,
119 doing the purge. Similarly, during a rollback, a record can be removed
120 if the stored roll ptr in the undo log points to a trx already (being) purged,
121 or if the roll ptr is NULL, i.e., it was a fresh insert. */
122 
123 /********************************************************************/
126 UNIV_INTERN
129 /*=================*/
130  trx_t* trx,
131  que_thr_t* parent,
132  mem_heap_t* heap)
133 {
134  undo_node_t* undo;
135 
136  ut_ad(trx && parent && heap);
137 
138  undo = static_cast<undo_node_t *>(mem_heap_alloc(heap, sizeof(undo_node_t)));
139 
140  undo->common.type = QUE_NODE_UNDO;
141  undo->common.parent = parent;
142 
143  undo->state = UNDO_NODE_FETCH_NEXT;
144  undo->trx = trx;
145 
146  btr_pcur_init(&(undo->pcur));
147 
148  undo->heap = mem_heap_create(256);
149 
150  return(undo);
151 }
152 
153 /***********************************************************/
160 UNIV_INTERN
161 ibool
163 /*==========================*/
164  undo_node_t* node)
165 {
166  dict_index_t* clust_index;
167  ibool found;
168  mtr_t mtr;
169  ibool ret;
170  rec_t* rec;
171  mem_heap_t* heap = NULL;
172  ulint offsets_[REC_OFFS_NORMAL_SIZE];
173  ulint* offsets = offsets_;
174  rec_offs_init(offsets_);
175 
176  mtr_start(&mtr);
177 
178  clust_index = dict_table_get_first_index(node->table);
179 
180  found = row_search_on_row_ref(&(node->pcur), BTR_MODIFY_LEAF,
181  node->table, node->ref, &mtr);
182 
183  rec = btr_pcur_get_rec(&(node->pcur));
184 
185  offsets = rec_get_offsets(rec, clust_index, offsets,
186  ULINT_UNDEFINED, &heap);
187 
188  if (!found || node->roll_ptr
189  != row_get_rec_roll_ptr(rec, clust_index, offsets)) {
190 
191  /* We must remove the reservation on the undo log record
192  BEFORE releasing the latch on the clustered index page: this
193  is to make sure that some thread will eventually undo the
194  modification corresponding to node->roll_ptr. */
195 
196  /* fputs("--------------------undoing a previous version\n",
197  stderr); */
198 
199  ret = FALSE;
200  } else {
201  row_ext_t** ext;
202 
204  /* In DYNAMIC or COMPRESSED format, there is
205  no prefix of externally stored columns in the
206  clustered index record. Build a cache of
207  column prefixes. */
208  ext = &node->ext;
209  } else {
210  /* REDUNDANT and COMPACT formats store a local
211  768-byte prefix of each externally stored
212  column. No cache is needed. */
213  ext = NULL;
214  node->ext = NULL;
215  }
216 
217  node->row = row_build(ROW_COPY_DATA, clust_index, rec,
218  offsets, NULL, ext, node->heap);
219  if (node->update) {
220  node->undo_row = dtuple_copy(node->row, node->heap);
221  row_upd_replace(node->undo_row, &node->undo_ext,
222  clust_index, node->update, node->heap);
223  } else {
224  node->undo_row = NULL;
225  node->undo_ext = NULL;
226  }
227 
228  btr_pcur_store_position(&(node->pcur), &mtr);
229 
230  ret = TRUE;
231  }
232 
233  btr_pcur_commit_specify_mtr(&(node->pcur), &mtr);
234 
235  if (UNIV_LIKELY_NULL(heap)) {
236  mem_heap_free(heap);
237  }
238  return(ret);
239 }
240 
241 /***********************************************************/
246 static
247 ulint
248 row_undo(
249 /*=====*/
250  undo_node_t* node,
251  que_thr_t* thr)
252 {
253  ulint err;
254  trx_t* trx;
255  roll_ptr_t roll_ptr;
256  ibool locked_data_dict;
257 
258  ut_ad(node && thr);
259 
260  trx = node->trx;
261 
262  if (node->state == UNDO_NODE_FETCH_NEXT) {
263 
265  trx->roll_limit,
266  &roll_ptr,
267  node->heap);
268  if (!node->undo_rec) {
269  /* Rollback completed for this query thread */
270 
271  thr->run_node = que_node_get_parent(node);
272 
273  return(DB_SUCCESS);
274  }
275 
276  node->roll_ptr = roll_ptr;
278 
279  if (trx_undo_roll_ptr_is_insert(roll_ptr)) {
280 
281  node->state = UNDO_NODE_INSERT;
282  } else {
283  node->state = UNDO_NODE_MODIFY;
284  }
285 
286  } else if (node->state == UNDO_NODE_PREV_VERS) {
287 
288  /* Undo should be done to the same clustered index record
289  again in this same rollback, restoring the previous version */
290 
291  roll_ptr = node->new_roll_ptr;
292 
293  node->undo_rec = trx_undo_get_undo_rec_low(roll_ptr,
294  node->heap);
295  node->roll_ptr = roll_ptr;
297 
298  if (trx_undo_roll_ptr_is_insert(roll_ptr)) {
299 
300  node->state = UNDO_NODE_INSERT;
301  } else {
302  node->state = UNDO_NODE_MODIFY;
303  }
304  }
305 
306  /* Prevent DROP TABLE etc. while we are rolling back this row.
307  If we are doing a TABLE CREATE or some other dictionary operation,
308  then we already have dict_operation_lock locked in x-mode. Do not
309  try to lock again, because that would cause a hang. */
310 
311  locked_data_dict = (trx->dict_operation_lock_mode == 0);
312 
313  if (locked_data_dict) {
314 
315  row_mysql_freeze_data_dictionary(trx);
316  }
317 
318  if (node->state == UNDO_NODE_INSERT) {
319 
320  err = row_undo_ins(node);
321 
322  node->state = UNDO_NODE_FETCH_NEXT;
323  } else {
324  ut_ad(node->state == UNDO_NODE_MODIFY);
325  err = row_undo_mod(node, thr);
326  }
327 
328  if (locked_data_dict) {
329 
331  }
332 
333  /* Do some cleanup */
334  btr_pcur_close(&(node->pcur));
335 
336  mem_heap_empty(node->heap);
337 
338  thr->run_node = node;
339 
340  return(err);
341 }
342 
343 /***********************************************************/
347 UNIV_INTERN
348 que_thr_t*
350 /*==========*/
351  que_thr_t* thr)
352 {
353  ulint err;
354  undo_node_t* node;
355  trx_t* trx;
356 
357  ut_ad(thr);
358 
359  srv_activity_count++;
360 
361  trx = thr_get_trx(thr);
362 
363  node = static_cast<undo_node_t *>(thr->run_node);
364 
365  ut_ad(que_node_get_type(node) == QUE_NODE_UNDO);
366 
367  err = row_undo(node, thr);
368 
369  trx->error_state = err;
370 
371  if (err != DB_SUCCESS) {
372  /* SQL error detected */
373 
374  fprintf(stderr, "InnoDB: Fatal error %lu in rollback.\n",
375  (ulong) err);
376 
377  if (err == DB_OUT_OF_FILE_SPACE) {
378  fprintf(stderr,
379  "InnoDB: Error 13 means out of tablespace.\n"
380  "InnoDB: Consider increasing"
381  " your tablespace.\n");
382 
383  exit(1);
384  }
385 
386  ut_error;
387 
388  return(NULL);
389  }
390 
391  return(thr);
392 }