开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
qam_rec.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：13k
源码类别：

MySQL数据库

开发平台：

Visual C++

qam_rec.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: qam_rec.c,v 11.69 2002/08/06 06:17:10 bostic 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 "dbinc/db_page.h"
  22. #include "dbinc/db_shash.h"
  23. #include "dbinc/db_am.h"
  24. #include "dbinc/lock.h"
  25. #include "dbinc/log.h"
  26. #include "dbinc/qam.h"
  28. /*
  29.  * __qam_incfirst_recover --
  30.  * Recovery function for incfirst.
  31.  *
  32.  * PUBLIC: int __qam_incfirst_recover
  33.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  34.  */
  35. int
  36. __qam_incfirst_recover(dbenv, dbtp, lsnp, op, info)
  37. DB_ENV *dbenv;
  38. DBT *dbtp;
  39. DB_LSN *lsnp;
  40. db_recops op;
  41. void *info;
  42. {
  43. __qam_incfirst_args *argp;
  44. DB *file_dbp;
  45. DBC *dbc;
  46. DB_LOCK lock;
  47. DB_MPOOLFILE *mpf;
  48. QMETA *meta;
  49. QUEUE_CURSOR *cp;
  50. db_pgno_t metapg;
  51. int exact, modified, ret, rec_ext;
  53. COMPQUIET(info, NULL);
  54. REC_PRINT(__qam_incfirst_print);
  55. REC_INTRO(__qam_incfirst_read, 1);
  57. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  59. if ((ret = __db_lget(dbc,
  60.     LCK_ROLLBACK, metapg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  61. goto done;
  62. if ((ret = mpf->get(mpf, &metapg, 0, &meta)) != 0) {
  63. if (DB_REDO(op)) {
  64. if ((ret = mpf->get(mpf,
  65.     &metapg, DB_MPOOL_CREATE, &meta)) != 0) {
  66. (void)__LPUT(dbc, lock);
  67. goto out;
  68. }
  69. meta->dbmeta.pgno = metapg;
  70. meta->dbmeta.type = P_QAMMETA;
  71. } else {
  72. *lsnp = argp->prev_lsn;
  73. ret = 0;
  74. (void)__LPUT(dbc, lock);
  75. goto out;
  76. }
  77. }
  79. modified = 0;
  81. /*
  82.  * Only move first_recno backwards so we pick up the aborted delete.
  83.  * When going forward we need to be careful since
  84.  * we may have bumped over a locked record.
  85.  */
  86. if (DB_UNDO(op)) {
  87. if (QAM_BEFORE_FIRST(meta, argp->recno)) {
  88. meta->first_recno = argp->recno;
  89. modified = 1;
  90. }
  91. } else {
  92. if (log_compare(&LSN(meta), lsnp) < 0) {
  93. LSN(meta) = *lsnp;
  94. modified = 1;
  95. }
  96. rec_ext = 0;
  97. if (meta->page_ext != 0)
  98. rec_ext = meta->page_ext * meta->rec_page;
  99. cp = (QUEUE_CURSOR *)dbc->internal;
  100. if (meta->first_recno == RECNO_OOB)
  101. meta->first_recno++;
  102. while (meta->first_recno != meta->cur_recno &&
  103.     !QAM_BEFORE_FIRST(meta, argp->recno + 1)) {
  104. if ((ret = __qam_position(dbc,
  105.     &meta->first_recno, QAM_READ, &exact)) != 0)
  106. goto err;
  107. if (cp->page != NULL)
  108. __qam_fput(file_dbp, cp->pgno, cp->page, 0);
  110. if (exact == 1)
  111. break;
  112. if (cp->page != NULL &&
  113.     rec_ext != 0 && meta->first_recno % rec_ext == 0)
  114. if ((ret =
  115.     __qam_fremove(file_dbp, cp->pgno)) != 0)
  116. goto err;
  117. meta->first_recno++;
  118. if (meta->first_recno == RECNO_OOB)
  119. meta->first_recno++;
  120. modified = 1;
  121. }
  122. }
  124. if ((ret = mpf->put(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  125. goto err1;
  127. (void)__LPUT(dbc, lock);
  129. done: *lsnp = argp->prev_lsn;
  130. ret = 0;
  132. if (0) {
  133. err: (void)mpf->put(mpf, meta, 0);
  134. err1: (void)__LPUT(dbc, lock);
  135. }
  137. out: REC_CLOSE;
  138. }
  140. /*
  141.  * __qam_mvptr_recover --
  142.  * Recovery function for mvptr.
  143.  *
  144.  * PUBLIC: int __qam_mvptr_recover
  145.  * PUBLIC:   __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  146.  */
  147. int
  148. __qam_mvptr_recover(dbenv, dbtp, lsnp, op, info)
  149. DB_ENV *dbenv;
  150. DBT *dbtp;
  151. DB_LSN *lsnp;
  152. db_recops op;
  153. void *info;
  154. {
  155. __qam_mvptr_args *argp;
  156. DB *file_dbp;
  157. DBC *dbc;
  158. DB_LOCK lock;
  159. DB_MPOOLFILE *mpf;
  160. QMETA *meta;
  161. db_pgno_t metapg;
  162. int cmp_n, cmp_p, modified, ret;
  164. COMPQUIET(info, NULL);
  165. REC_PRINT(__qam_mvptr_print);
  166. REC_INTRO(__qam_mvptr_read, 1);
  168. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  170. if ((ret = __db_lget(dbc,
  171.     LCK_ROLLBACK, metapg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  172. goto done;
  173. if ((ret = mpf->get(mpf, &metapg, 0, &meta)) != 0) {
  174. if (DB_REDO(op)) {
  175. if ((ret = mpf->get(mpf,
  176.     &metapg, DB_MPOOL_CREATE, &meta)) != 0) {
  177. (void)__LPUT(dbc, lock);
  178. goto out;
  179. }
  180. meta->dbmeta.pgno = metapg;
  181. meta->dbmeta.type = P_QAMMETA;
  182. } else {
  183. *lsnp = argp->prev_lsn;
  184. ret = 0;
  185. (void)__LPUT(dbc, lock);
  186. goto out;
  187. }
  188. }
  190. modified = 0;
  191. cmp_n = log_compare(lsnp, &LSN(meta));
  192. cmp_p = log_compare(&LSN(meta), &argp->metalsn);
  194. /*
  195.  * Under normal circumstances, we never undo a movement of one of
  196.  * the pointers.  Just move them along regardless of abort/commit.
  197.  *
  198.  * If we're undoing a truncate, we need to reset the pointers to
  199.  * their state before the truncate.
  200.  */
  201. if (DB_UNDO(op) && (argp->opcode & QAM_TRUNCATE)) {
  202. if (cmp_n == 0) {
  203. meta->first_recno = argp->old_first;
  204. meta->cur_recno = argp->old_cur;
  205. modified = 1;
  206. meta->dbmeta.lsn = argp->metalsn;
  207. }
  208. } else if (cmp_p == 0) {
  209. if (argp->opcode & QAM_SETFIRST)
  210. meta->first_recno = argp->new_first;
  212. if (argp->opcode & QAM_SETCUR)
  213. meta->cur_recno = argp->new_cur;
  215. modified = 1;
  216. meta->dbmeta.lsn = *lsnp;
  217. }
  219. if ((ret = mpf->put(mpf, meta, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  220. goto out;
  222. (void)__LPUT(dbc, lock);
  224. done: *lsnp = argp->prev_lsn;
  225. ret = 0;
  227. out: REC_CLOSE;
  228. }
  230. /*
  231.  * __qam_del_recover --
  232.  * Recovery function for del.
  233.  * Non-extent version or if there is no data (zero len).
  234.  *
  235.  * PUBLIC: int __qam_del_recover
  236.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  237.  */
  238. int
  239. __qam_del_recover(dbenv, dbtp, lsnp, op, info)
  240. DB_ENV *dbenv;
  241. DBT *dbtp;
  242. DB_LSN *lsnp;
  243. db_recops op;
  244. void *info;
  245. {
  246. __qam_del_args *argp;
  247. DB *file_dbp;
  248. DBC *dbc;
  249. DB_LOCK lock;
  250. DB_MPOOLFILE *mpf;
  251. QAMDATA *qp;
  252. QMETA *meta;
  253. QPAGE *pagep;
  254. db_pgno_t metapg;
  255. int cmp_n, modified, ret;
  257. COMPQUIET(info, NULL);
  258. REC_PRINT(__qam_del_print);
  259. REC_INTRO(__qam_del_read, 1);
  261. if ((ret = __qam_fget(file_dbp,
  262.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  263. goto out;
  265. modified = 0;
  266. if (pagep->pgno == PGNO_INVALID) {
  267. pagep->pgno = argp->pgno;
  268. pagep->type = P_QAMDATA;
  269. modified = 1;
  270. }
  272. cmp_n = log_compare(lsnp, &LSN(pagep));
  274. if (DB_UNDO(op)) {
  275. /* make sure first is behind us */
  276. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  277. if ((ret = __db_lget(dbc,
  278.     LCK_ROLLBACK, metapg, DB_LOCK_WRITE, 0, &lock)) != 0)
  279. goto err;
  280. if ((ret = mpf->get(mpf, &metapg, 0, &meta)) != 0) {
  281. (void)__LPUT(dbc, lock);
  282. goto err;
  283. }
  284. if (meta->first_recno == RECNO_OOB ||
  285.     (QAM_BEFORE_FIRST(meta, argp->recno) &&
  286.     (meta->first_recno <= meta->cur_recno ||
  287.     meta->first_recno -
  288.     argp->recno < argp->recno - meta->cur_recno))) {
  289. meta->first_recno = argp->recno;
  290. (void)mpf->put(mpf, meta, DB_MPOOL_DIRTY);
  291. } else
  292. (void)mpf->put(mpf, meta, 0);
  293. (void)__LPUT(dbc, lock);
  295. /* Need to undo delete - mark the record as present */
  296. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  297. F_SET(qp, QAM_VALID);
  299. /*
  300.  * Move the LSN back to this point;  do not move it forward.
  301.  * Only move it back if we're in recovery.  If we're in
  302.  * an abort, because we don't hold a page lock, we could
  303.  * foul up a concurrent put.  Having too late an LSN
  304.  * is harmless in queue except when we're determining
  305.  * what we need to roll forward during recovery.  [#2588]
  306.  */
  307. if (op == DB_TXN_BACKWARD_ROLL && cmp_n <= 0)
  308. LSN(pagep) = argp->lsn;
  309. modified = 1;
  310. } else if (cmp_n > 0 && DB_REDO(op)) {
  311. /* Need to redo delete - clear the valid bit */
  312. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  313. F_CLR(qp, QAM_VALID);
  314. LSN(pagep) = *lsnp;
  315. modified = 1;
  316. }
  317. if ((ret = __qam_fput(file_dbp,
  318.     argp->pgno, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  319. goto out;
  321. done: *lsnp = argp->prev_lsn;
  322. ret = 0;
  324. if (0) {
  325. err: (void)__qam_fput(file_dbp, argp->pgno, pagep, 0);
  326. }
  327. out: REC_CLOSE;
  328. }
  330. /*
  331.  * __qam_delext_recover --
  332.  * Recovery function for del in an extent based queue.
  333.  *
  334.  * PUBLIC: int __qam_delext_recover __P((DB_ENV *,
  335.  * PUBLIC:     DBT *, DB_LSN *, db_recops, void *));
  336.  */
  337. int
  338. __qam_delext_recover(dbenv, dbtp, lsnp, op, info)
  339. DB_ENV *dbenv;
  340. DBT *dbtp;
  341. DB_LSN *lsnp;
  342. db_recops op;
  343. void *info;
  344. {
  345. __qam_delext_args *argp;
  346. DB *file_dbp;
  347. DBC *dbc;
  348. DB_LOCK lock;
  349. DB_MPOOLFILE *mpf;
  350. QAMDATA *qp;
  351. QMETA *meta;
  352. QPAGE *pagep;
  353. db_pgno_t metapg;
  354. int cmp_n, modified, ret;
  356. COMPQUIET(info, NULL);
  357. REC_PRINT(__qam_delext_print);
  358. REC_INTRO(__qam_delext_read, 1);
  360. if ((ret = __qam_fget(file_dbp, &argp->pgno, 0, &pagep)) != 0) {
  361. if (ret != DB_PAGE_NOTFOUND && ret != ENOENT)
  362. goto out;
  363. /*
  364.  * If we are redoing a delete and the page is not there
  365.  * we are done.
  366.  */
  367. if (DB_REDO(op))
  368. goto done;
  369. if ((ret = __qam_fget(file_dbp,
  370.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  371. goto out;
  372. }
  374. modified = 0;
  375. if (pagep->pgno == PGNO_INVALID) {
  376. pagep->pgno = argp->pgno;
  377. pagep->type = P_QAMDATA;
  378. modified = 1;
  379. }
  381. cmp_n = log_compare(lsnp, &LSN(pagep));
  383. if (DB_UNDO(op)) {
  384. /* make sure first is behind us */
  385. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  386. if ((ret = __db_lget(dbc,
  387.     LCK_ROLLBACK, metapg, DB_LOCK_WRITE, 0, &lock)) != 0)
  388. goto err;
  389. if ((ret = mpf->get(mpf, &metapg, 0, &meta)) != 0) {
  390. (void)__LPUT(dbc, lock);
  391. goto err;
  392. }
  393. if (meta->first_recno == RECNO_OOB ||
  394.     (QAM_BEFORE_FIRST(meta, argp->recno) &&
  395.     (meta->first_recno <= meta->cur_recno ||
  396.     meta->first_recno -
  397.     argp->recno < argp->recno - meta->cur_recno))) {
  398. meta->first_recno = argp->recno;
  399. (void)mpf->put(mpf, meta, DB_MPOOL_DIRTY);
  400. } else
  401. (void)mpf->put(mpf, meta, 0);
  402. (void)__LPUT(dbc, lock);
  404. if ((ret = __qam_pitem(dbc, pagep,
  405.     argp->indx, argp->recno, &argp->data)) != 0)
  406. goto err;
  408. /*
  409.  * Move the LSN back to this point;  do not move it forward.
  410.  * Only move it back if we're in recovery.  If we're in
  411.  * an abort, because we don't hold a page lock, we could
  412.  * foul up a concurrent put.  Having too late an LSN
  413.  * is harmless in queue except when we're determining
  414.  * what we need to roll forward during recovery.  [#2588]
  415.  */
  416. if (op == DB_TXN_BACKWARD_ROLL && cmp_n <= 0)
  417. LSN(pagep) = argp->lsn;
  418. modified = 1;
  419. } else if (cmp_n > 0 && DB_REDO(op)) {
  420. /* Need to redo delete - clear the valid bit */
  421. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  422. F_CLR(qp, QAM_VALID);
  423. LSN(pagep) = *lsnp;
  424. modified = 1;
  425. }
  426. if ((ret = __qam_fput(file_dbp,
  427.     argp->pgno, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  428. goto out;
  430. done: *lsnp = argp->prev_lsn;
  431. ret = 0;
  433. if (0) {
  434. err: (void)__qam_fput(file_dbp, argp->pgno, pagep, 0);
  435. }
  436. out: REC_CLOSE;
  437. }
  439. /*
  440.  * __qam_add_recover --
  441.  * Recovery function for add.
  442.  *
  443.  * PUBLIC: int __qam_add_recover
  444.  * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
  445.  */
  446. int
  447. __qam_add_recover(dbenv, dbtp, lsnp, op, info)
  448. DB_ENV *dbenv;
  449. DBT *dbtp;
  450. DB_LSN *lsnp;
  451. db_recops op;
  452. void *info;
  453. {
  454. __qam_add_args *argp;
  455. DB *file_dbp;
  456. DBC *dbc;
  457. DB_MPOOLFILE *mpf;
  458. QAMDATA *qp;
  459. QMETA *meta;
  460. QPAGE *pagep;
  461. db_pgno_t metapg;
  462. int cmp_n, meta_dirty, modified, ret;
  464. COMPQUIET(info, NULL);
  465. REC_PRINT(__qam_add_print);
  466. REC_INTRO(__qam_add_read, 1);
  468. modified = 0;
  469. if ((ret = __qam_fget(file_dbp, &argp->pgno, 0, &pagep)) != 0) {
  470. if (ret != DB_PAGE_NOTFOUND && ret != ENOENT)
  471. goto out;
  472. /*
  473.  * If we are undoing an append and the page is not there
  474.  * we are done.
  475.  */
  476. if (DB_UNDO(op))
  477. goto done;
  478. if ((ret = __qam_fget(file_dbp,
  479.     &argp->pgno, DB_MPOOL_CREATE, &pagep)) != 0)
  480. goto out;
  481. }
  483. if (pagep->pgno == PGNO_INVALID) {
  484. pagep->pgno = argp->pgno;
  485. pagep->type = P_QAMDATA;
  486. modified = 1;
  487. }
  489. cmp_n = log_compare(lsnp, &LSN(pagep));
  491. if (DB_REDO(op)) {
  492. /* Fix meta-data page. */
  493. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  494. if ((ret = mpf->get(mpf, &metapg, 0, &meta)) != 0)
  495. goto err;
  496. meta_dirty = 0;
  497. if (QAM_BEFORE_FIRST(meta, argp->recno)) {
  498. meta->first_recno = argp->recno;
  499. meta_dirty = 1;
  500. }
  501. if (argp->recno == meta->cur_recno ||
  502.    QAM_AFTER_CURRENT(meta, argp->recno)) {
  503. meta->cur_recno = argp->recno + 1;
  504. meta_dirty = 1;
  505. }
  506. if ((ret =
  507.     mpf->put(mpf, meta, meta_dirty? DB_MPOOL_DIRTY : 0)) != 0)
  508. goto err;
  510. /* Now update the actual page if necessary. */
  511. if (cmp_n > 0) {
  512. /* Need to redo add - put the record on page */
  513. if ((ret = __qam_pitem(dbc,
  514.     pagep, argp->indx, argp->recno, &argp->data)) != 0)
  515. goto err;
  516. LSN(pagep) = *lsnp;
  517. modified = 1;
  518. /* Make sure pointers include this record. */
  519. metapg = ((QUEUE *)file_dbp->q_internal)->q_meta;
  520. }
  521. } else if (DB_UNDO(op)) {
  522. /*
  523.  * Need to undo add
  524.  * If this was an overwrite, put old record back.
  525.  * Otherwise just clear the valid bit
  526.  */
  527. if (argp->olddata.size != 0) {
  528. if ((ret = __qam_pitem(dbc, pagep,
  529.     argp->indx, argp->recno, &argp->olddata)) != 0)
  530. goto err;
  532. if (!(argp->vflag & QAM_VALID)) {
  533. qp = QAM_GET_RECORD(
  534.     file_dbp, pagep, argp->indx);
  535. F_CLR(qp, QAM_VALID);
  536. }
  537. modified = 1;
  538. } else {
  539. qp = QAM_GET_RECORD(file_dbp, pagep, argp->indx);
  540. qp->flags = 0;
  541. modified = 1;
  542. }
  544. /*
  545.  * Move the LSN back to this point;  do not move it forward.
  546.  * Only move it back if we're in recovery.  If we're in
  547.  * an abort, because we don't hold a page lock, we could
  548.  * foul up a concurrent put.  Having too late an LSN
  549.  * is harmless in queue except when we're determining
  550.  * what we need to roll forward during recovery.  [#2588]
  551.  */
  552. if (op == DB_TXN_BACKWARD_ROLL && cmp_n <= 0)
  553. LSN(pagep) = argp->lsn;
  554. }
  556. if ((ret = __qam_fput(file_dbp,
  557.     argp->pgno, pagep, modified ? DB_MPOOL_DIRTY : 0)) != 0)
  558. goto out;
  560. done: *lsnp = argp->prev_lsn;
  561. ret = 0;
  563. if (0) {
  564. err: (void)__qam_fput(file_dbp, argp->pgno, pagep, 0);
  565. }
  567. out: REC_CLOSE;
  568. }