Category

Development Platform
Home > SourceCode/Document > Database system > MySQL > View Code
db_rec.c
Package: mysql-3.23.35.tar.gz　[view]
Upload User: tsgydb
Upload Date: 2007-04-14
Package Size: 10674k
Code Size: 13k
Category:

MySQL

Development Platform:

Visual C++

db_rec.c：Code Content
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996, 1997, 1998, 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: db_rec.c,v 11.10 2000/08/03 15:32:19 ubell Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  17. #include <string.h>
  18. #endif
  20. #include "db_int.h"
  21. #include "db_page.h"
  22. #include "log.h"
  23. #include "hash.h"
  25. /*
  26.  * PUBLIC: int __db_addrem_recover
  27.  * PUBLIC:    __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  28.  *
  29.  * This log message is generated whenever we add or remove a duplicate
  30.  * to/from a duplicate page.  On recover, we just do the opposite.
  31.  */
  32. int
  33. __db_addrem_recover(dbenv, dbtp, lsnp, op, info)
  34. DB_ENV *dbenv;
  35. DBT *dbtp;
  36. DB_LSN *lsnp;
  37. db_recops op;
  38. void *info;
  39. {
  40. __db_addrem_args *argp;
  41. DB *file_dbp;
  42. DBC *dbc;
  43. DB_MPOOLFILE *mpf;
  44. PAGE *pagep;
  45. u_int32_t change;
  46. int cmp_n, cmp_p, ret;
  48. COMPQUIET(info, NULL);
  49. REC_PRINT(__db_addrem_print);
  50. REC_INTRO(__db_addrem_read, 1);
  52. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  53. if (DB_UNDO(op)) {
  54. /*
  55.  * We are undoing and the page doesn't exist.  That
  56.  * is equivalent to having a pagelsn of 0, so we
  57.  * would not have to undo anything.  In this case,
  58.  * don't bother creating a page.
  59.  */
  60. goto done;
  61. } else
  62. if ((ret = memp_fget(mpf,
  63.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  64. goto out;
  65. }
  67. cmp_n = log_compare(lsnp, &LSN(pagep));
  68. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  69. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  70. change = 0;
  71. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_ADD_DUP) ||
  72.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_REM_DUP)) {
  74. /* Need to redo an add, or undo a delete. */
  75. if ((ret = __db_pitem(dbc, pagep, argp->indx, argp->nbytes,
  76.     argp->hdr.size == 0 ? NULL : &argp->hdr,
  77.     argp->dbt.size == 0 ? NULL : &argp->dbt)) != 0)
  78. goto out;
  80. change = DB_MPOOL_DIRTY;
  82. } else if ((cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_ADD_DUP) ||
  83.     (cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_REM_DUP)) {
  84. /* Need to undo an add, or redo a delete. */
  85. if ((ret = __db_ditem(dbc,
  86.     pagep, argp->indx, argp->nbytes)) != 0)
  87. goto out;
  88. change = DB_MPOOL_DIRTY;
  89. }
  91. if (change) {
  92. if (DB_REDO(op))
  93. LSN(pagep) = *lsnp;
  94. else
  95. LSN(pagep) = argp->pagelsn;
  96. }
  98. if ((ret = memp_fput(mpf, pagep, change)) != 0)
  99. goto out;
  101. done: *lsnp = argp->prev_lsn;
  102. ret = 0;
  104. out: REC_CLOSE;
  105. }
  107. /*
  108.  * PUBLIC: int __db_big_recover
  109.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  110.  */
  111. int
  112. __db_big_recover(dbenv, dbtp, lsnp, op, info)
  113. DB_ENV *dbenv;
  114. DBT *dbtp;
  115. DB_LSN *lsnp;
  116. db_recops op;
  117. void *info;
  118. {
  119. __db_big_args *argp;
  120. DB *file_dbp;
  121. DBC *dbc;
  122. DB_MPOOLFILE *mpf;
  123. PAGE *pagep;
  124. u_int32_t change;
  125. int cmp_n, cmp_p, ret;
  127. COMPQUIET(info, NULL);
  128. REC_PRINT(__db_big_print);
  129. REC_INTRO(__db_big_read, 1);
  131. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  132. if (DB_UNDO(op)) {
  133. /*
  134.  * We are undoing and the page doesn't exist.  That
  135.  * is equivalent to having a pagelsn of 0, so we
  136.  * would not have to undo anything.  In this case,
  137.  * don't bother creating a page.
  138.  */
  139. ret = 0;
  140. goto ppage;
  141. } else
  142. if ((ret = memp_fget(mpf,
  143.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  144. goto out;
  145. }
  147. /*
  148.  * There are three pages we need to check.  The one on which we are
  149.  * adding data, the previous one whose next_pointer may have
  150.  * been updated, and the next one whose prev_pointer may have
  151.  * been updated.
  152.  */
  153. cmp_n = log_compare(lsnp, &LSN(pagep));
  154. cmp_p = log_compare(&LSN(pagep), &argp->pagelsn);
  155. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->pagelsn);
  156. change = 0;
  157. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_ADD_BIG) ||
  158.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_REM_BIG)) {
  159. /* We are either redo-ing an add, or undoing a delete. */
  160. P_INIT(pagep, file_dbp->pgsize, argp->pgno, argp->prev_pgno,
  161. argp->next_pgno, 0, P_OVERFLOW);
  162. OV_LEN(pagep) = argp->dbt.size;
  163. OV_REF(pagep) = 1;
  164. memcpy((u_int8_t *)pagep + P_OVERHEAD, argp->dbt.data,
  165.     argp->dbt.size);
  166. PREV_PGNO(pagep) = argp->prev_pgno;
  167. change = DB_MPOOL_DIRTY;
  168. } else if ((cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_ADD_BIG) ||
  169.     (cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_REM_BIG)) {
  170. /*
  171.  * We are either undo-ing an add or redo-ing a delete.
  172.  * The page is about to be reclaimed in either case, so
  173.  * there really isn't anything to do here.
  174.  */
  175. change = DB_MPOOL_DIRTY;
  176. }
  177. if (change)
  178. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->pagelsn;
  180. if ((ret = memp_fput(mpf, pagep, change)) != 0)
  181. goto out;
  183. /* Now check the previous page. */
  184. ppage: if (argp->prev_pgno != PGNO_INVALID) {
  185. change = 0;
  186. if ((ret = memp_fget(mpf, &argp->prev_pgno, 0, &pagep)) != 0) {
  187. if (DB_UNDO(op)) {
  188. /*
  189.  * We are undoing and the page doesn't exist.
  190.  * That is equivalent to having a pagelsn of 0,
  191.  * so we would not have to undo anything.  In
  192.  * this case, don't bother creating a page.
  193.  */
  194. *lsnp = argp->prev_lsn;
  195. ret = 0;
  196. goto npage;
  197. } else
  198. if ((ret = memp_fget(mpf, &argp->prev_pgno,
  199.     DB_MPOOL_CREATE, &pagep)) != 0)
  200. goto out;
  201. }
  203. cmp_n = log_compare(lsnp, &LSN(pagep));
  204. cmp_p = log_compare(&LSN(pagep), &argp->prevlsn);
  205. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->prevlsn);
  207. if ((cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_ADD_BIG) ||
  208.     (cmp_n == 0 && DB_UNDO(op) && argp->opcode == DB_REM_BIG)) {
  209. /* Redo add, undo delete. */
  210. NEXT_PGNO(pagep) = argp->pgno;
  211. change = DB_MPOOL_DIRTY;
  212. } else if ((cmp_n == 0 &&
  213.     DB_UNDO(op) && argp->opcode == DB_ADD_BIG) ||
  214.     (cmp_p == 0 && DB_REDO(op) && argp->opcode == DB_REM_BIG)) {
  215. /* Redo delete, undo add. */
  216. NEXT_PGNO(pagep) = argp->next_pgno;
  217. change = DB_MPOOL_DIRTY;
  218. }
  219. if (change)
  220. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->prevlsn;
  221. if ((ret = memp_fput(mpf, pagep, change)) != 0)
  222. goto out;
  223. }
  225. /* Now check the next page.  Can only be set on a delete. */
  226. npage: if (argp->next_pgno != PGNO_INVALID) {
  227. change = 0;
  228. if ((ret = memp_fget(mpf, &argp->next_pgno, 0, &pagep)) != 0) {
  229. if (DB_UNDO(op)) {
  230. /*
  231.  * We are undoing and the page doesn't exist.
  232.  * That is equivalent to having a pagelsn of 0,
  233.  * so we would not have to undo anything.  In
  234.  * this case, don't bother creating a page.
  235.  */
  236. goto done;
  237. } else
  238. if ((ret = memp_fget(mpf, &argp->next_pgno,
  239.     DB_MPOOL_CREATE, &pagep)) != 0)
  240. goto out;
  241. }
  243. cmp_n = log_compare(lsnp, &LSN(pagep));
  244. cmp_p = log_compare(&LSN(pagep), &argp->nextlsn);
  245. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->nextlsn);
  246. if (cmp_p == 0 && DB_REDO(op)) {
  247. PREV_PGNO(pagep) = PGNO_INVALID;
  248. change = DB_MPOOL_DIRTY;
  249. } else if (cmp_n == 0 && DB_UNDO(op)) {
  250. PREV_PGNO(pagep) = argp->pgno;
  251. change = DB_MPOOL_DIRTY;
  252. }
  253. if (change)
  254. LSN(pagep) = DB_REDO(op) ? *lsnp : argp->nextlsn;
  255. if ((ret = memp_fput(mpf, pagep, change)) != 0)
  256. goto out;
  257. }
  259. done: *lsnp = argp->prev_lsn;
  260. ret = 0;
  262. out: REC_CLOSE;
  263. }
  265. /*
  266.  * __db_ovref_recover --
  267.  * Recovery function for __db_ovref().
  268.  *
  269.  * PUBLIC: int __db_ovref_recover __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  270.  */
  271. int
  272. __db_ovref_recover(dbenv, dbtp, lsnp, op, info)
  273. DB_ENV *dbenv;
  274. DBT *dbtp;
  275. DB_LSN *lsnp;
  276. db_recops op;
  277. void *info;
  278. {
  279. __db_ovref_args *argp;
  280. DB *file_dbp;
  281. DBC *dbc;
  282. DB_MPOOLFILE *mpf;
  283. PAGE *pagep;
  284. int cmp, modified, ret;
  286. COMPQUIET(info, NULL);
  287. REC_PRINT(__db_ovref_print);
  288. REC_INTRO(__db_ovref_read, 1);
  290. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  291. if (DB_UNDO(op))
  292. goto done;
  293. (void)__db_pgerr(file_dbp, argp->pgno);
  294. goto out;
  295. }
  297. modified = 0;
  298. cmp = log_compare(&LSN(pagep), &argp->lsn);
  299. CHECK_LSN(op, cmp, &LSN(pagep), &argp->lsn);
  300. if (cmp == 0 && DB_REDO(op)) {
  301. /* Need to redo update described. */
  302. OV_REF(pagep) += argp->adjust;
  304. pagep->lsn = *lsnp;
  305. modified = 1;
  306. } else if (log_compare(lsnp, &LSN(pagep)) == 0 && DB_UNDO(op)) {
  307. /* Need to undo update described. */
  308. OV_REF(pagep) -= argp->adjust;
  310. pagep->lsn = argp->lsn;
  311. modified = 1;
  312. }
  313. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  314. goto out;
  316. done: *lsnp = argp->prev_lsn;
  317. ret = 0;
  319. out: REC_CLOSE;
  320. }
  322. /*
  323.  * __db_relink_recover --
  324.  * Recovery function for relink.
  325.  *
  326.  * PUBLIC: int __db_relink_recover
  327.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  328.  */
  329. int
  330. __db_relink_recover(dbenv, dbtp, lsnp, op, info)
  331. DB_ENV *dbenv;
  332. DBT *dbtp;
  333. DB_LSN *lsnp;
  334. db_recops op;
  335. void *info;
  336. {
  337. __db_relink_args *argp;
  338. DB *file_dbp;
  339. DBC *dbc;
  340. DB_MPOOLFILE *mpf;
  341. PAGE *pagep;
  342. int cmp_n, cmp_p, modified, ret;
  344. COMPQUIET(info, NULL);
  345. REC_PRINT(__db_relink_print);
  346. REC_INTRO(__db_relink_read, 1);
  348. /*
  349.  * There are up to three pages we need to check -- the page, and the
  350.  * previous and next pages, if they existed.  For a page add operation,
  351.  * the current page is the result of a split and is being recovered
  352.  * elsewhere, so all we need do is recover the next page.
  353.  */
  354. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0) {
  355. if (DB_REDO(op)) {
  356. (void)__db_pgerr(file_dbp, argp->pgno);
  357. goto out;
  358. }
  359. goto next2;
  360. }
  361. modified = 0;
  362. if (argp->opcode == DB_ADD_PAGE)
  363. goto next1;
  365. cmp_p = log_compare(&LSN(pagep), &argp->lsn);
  366. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn);
  367. if (cmp_p == 0 && DB_REDO(op)) {
  368. /* Redo the relink. */
  369. pagep->lsn = *lsnp;
  370. modified = 1;
  371. } else if (log_compare(lsnp, &LSN(pagep)) == 0 && DB_UNDO(op)) {
  372. /* Undo the relink. */
  373. pagep->next_pgno = argp->next;
  374. pagep->prev_pgno = argp->prev;
  376. pagep->lsn = argp->lsn;
  377. modified = 1;
  378. }
  379. next1: if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  380. goto out;
  382. next2: if ((ret = memp_fget(mpf, &argp->next, 0, &pagep)) != 0) {
  383. if (DB_REDO(op)) {
  384. (void)__db_pgerr(file_dbp, argp->next);
  385. goto out;
  386. }
  387. goto prev;
  388. }
  389. modified = 0;
  390. cmp_n = log_compare(lsnp, &LSN(pagep));
  391. cmp_p = log_compare(&LSN(pagep), &argp->lsn_next);
  392. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn_next);
  393. if ((argp->opcode == DB_REM_PAGE && cmp_p == 0 && DB_REDO(op)) ||
  394.     (argp->opcode == DB_ADD_PAGE && cmp_n == 0 && DB_UNDO(op))) {
  395. /* Redo the remove or undo the add. */
  396. pagep->prev_pgno = argp->prev;
  398. modified = 1;
  399. } else if ((argp->opcode == DB_REM_PAGE && cmp_n == 0 && DB_UNDO(op)) ||
  400.     (argp->opcode == DB_ADD_PAGE && cmp_p == 0 && DB_REDO(op))) {
  401. /* Undo the remove or redo the add. */
  402. pagep->prev_pgno = argp->pgno;
  404. modified = 1;
  405. }
  406. if (modified == 1) {
  407. if (DB_UNDO(op))
  408. pagep->lsn = argp->lsn_next;
  409. else
  410. pagep->lsn = *lsnp;
  411. }
  412. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  413. goto out;
  414. if (argp->opcode == DB_ADD_PAGE)
  415. goto done;
  417. prev: if ((ret = memp_fget(mpf, &argp->prev, 0, &pagep)) != 0) {
  418. if (DB_REDO(op)) {
  419. (void)__db_pgerr(file_dbp, argp->prev);
  420. goto out;
  421. }
  422. goto done;
  423. }
  424. modified = 0;
  425. cmp_p = log_compare(&LSN(pagep), &argp->lsn_prev);
  426. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->lsn_prev);
  427. if (cmp_p == 0 && DB_REDO(op)) {
  428. /* Redo the relink. */
  429. pagep->next_pgno = argp->next;
  431. modified = 1;
  432. } else if (log_compare(lsnp, &LSN(pagep)) == 0 && DB_UNDO(op)) {
  433. /* Undo the relink. */
  434. pagep->next_pgno = argp->pgno;
  436. modified = 1;
  437. }
  438. if (modified == 1) {
  439. if (DB_UNDO(op))
  440. pagep->lsn = argp->lsn_prev;
  441. else
  442. pagep->lsn = *lsnp;
  443. }
  444. if ((ret = memp_fput(mpf, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  445. goto out;
  447. done: *lsnp = argp->prev_lsn;
  448. ret = 0;
  450. out: REC_CLOSE;
  451. }
  453. /*
  454.  * __db_debug_recover --
  455.  * Recovery function for debug.
  456.  *
  457.  * PUBLIC: int __db_debug_recover __P((DB_ENV *,
  458.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *));
  459.  */
  460. int
  461. __db_debug_recover(dbenv, dbtp, lsnp, op, info)
  462. DB_ENV *dbenv;
  463. DBT *dbtp;
  464. DB_LSN *lsnp;
  465. db_recops op;
  466. void *info;
  467. {
  468. __db_debug_args *argp;
  469. int ret;
  471. COMPQUIET(op, 0);
  472. COMPQUIET(dbenv, NULL);
  473. COMPQUIET(info, NULL);
  475. REC_PRINT(__db_debug_print);
  476. REC_NOOP_INTRO(__db_debug_read);
  478. *lsnp = argp->prev_lsn;
  479. ret = 0;
  481. REC_NOOP_CLOSE;
  482. }
  484. /*
  485.  * __db_noop_recover --
  486.  * Recovery function for noop.
  487.  *
  488.  * PUBLIC: int __db_noop_recover __P((DB_ENV *,
  489.  * PUBLIC:      DBT *, DB_LSN *, db_recops, void *));
  490.  */
  491. int
  492. __db_noop_recover(dbenv, dbtp, lsnp, op, info)
  493. DB_ENV *dbenv;
  494. DBT *dbtp;
  495. DB_LSN *lsnp;
  496. db_recops op;
  497. void *info;
  498. {
  499. __db_noop_args *argp;
  500. DB *file_dbp;
  501. DBC *dbc;
  502. DB_MPOOLFILE *mpf;
  503. PAGE *pagep;
  504. u_int32_t change;
  505. int cmp_n, cmp_p, ret;
  507. COMPQUIET(info, NULL);
  508. REC_PRINT(__db_noop_print);
  509. REC_INTRO(__db_noop_read, 0);
  511. if ((ret = memp_fget(mpf, &argp->pgno, 0, &pagep)) != 0)
  512. goto out;
  514. cmp_n = log_compare(lsnp, &LSN(pagep));
  515. cmp_p = log_compare(&LSN(pagep), &argp->prevlsn);
  516. CHECK_LSN(op, cmp_p, &LSN(pagep), &argp->prevlsn);
  517. change = 0;
  518. if (cmp_p == 0 && DB_REDO(op)) {
  519. LSN(pagep) = *lsnp;
  520. change = DB_MPOOL_DIRTY;
  521. } else if (cmp_n == 0 && DB_UNDO(op)) {
  522. LSN(pagep) = argp->prevlsn;
  523. change = DB_MPOOL_DIRTY;
  524. }
  525. ret = memp_fput(mpf, pagep, change);
  527. done: *lsnp = argp->prev_lsn;
  528. out: REC_CLOSE;
  529. }