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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
bt_curadj.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：15k
源码类别：

MySQL数据库

开发平台：

Visual C++

bt_curadj.c：源码内容
  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: bt_curadj.c,v 11.20 2001/01/17 16:15:49 bostic Exp $";
  12. #endif /* not lint */
  14. #ifndef NO_SYSTEM_INCLUDES
  15. #include <sys/types.h>
  16. #endif
  18. #include "db_int.h"
  19. #include "db_page.h"
  20. #include "btree.h"
  21. #include "txn.h"
  23. static int __bam_opd_cursor __P((DB *, DBC *, db_pgno_t, u_int32_t, u_int32_t));
  25. #ifdef DEBUG
  26. /*
  27.  * __bam_cprint --
  28.  * Display the current internal cursor.
  29.  *
  30.  * PUBLIC: void __bam_cprint __P((DBC *));
  31.  */
  32. void
  33. __bam_cprint(dbc)
  34. DBC *dbc;
  35. {
  36. BTREE_CURSOR *cp;
  38. cp = (BTREE_CURSOR *)dbc->internal;
  40. fprintf(stderr, "tinternal: ovflsize: %lu", (u_long)cp->ovflsize);
  41. if (dbc->dbtype == DB_RECNO)
  42. fprintf(stderr, " recno: %lu", (u_long)cp->recno);
  43. if (F_ISSET(cp, C_DELETED))
  44. fprintf(stderr, " (deleted)");
  45. fprintf(stderr, "n");
  46. }
  47. #endif
  49. /*
  50.  * Cursor adjustments are logged if they are for subtransactions.  This is
  51.  * because it's possible for a subtransaction to adjust cursors which will
  52.  * still be active after the subtransaction aborts, and so which must be
  53.  * restored to their previous locations.  Cursors that can be both affected
  54.  * by our cursor adjustments and active after our transaction aborts can
  55.  * only be found in our parent transaction -- cursors in other transactions,
  56.  * including other child transactions of our parent, must have conflicting
  57.  * locker IDs, and so cannot be affected by adjustments in this transaction.
  58.  */
  60. /*
  61.  * __bam_ca_delete --
  62.  * Update the cursors when items are deleted and when already deleted
  63.  * items are overwritten.  Return the number of relevant cursors found.
  64.  *
  65.  * PUBLIC: int __bam_ca_delete __P((DB *, db_pgno_t, u_int32_t, int));
  66.  */
  67. int
  68. __bam_ca_delete(dbp, pgno, indx, delete)
  69. DB *dbp;
  70. db_pgno_t pgno;
  71. u_int32_t indx;
  72. int delete;
  73. {
  74. BTREE_CURSOR *cp;
  75. DB *ldbp;
  76. DB_ENV *dbenv;
  77. DBC *dbc;
  78. int count; /* !!!: Has to contain max number of cursors. */
  80. dbenv = dbp->dbenv;
  82. /*
  83.  * Adjust the cursors.  We have the page write locked, so the
  84.  * only other cursors that can be pointing at a page are
  85.  * those in the same thread of control.  Unfortunately, we don't
  86.  * know that they're using the same DB handle, so traverse
  87.  * all matching DB handles in the same DB_ENV, then all cursors
  88.  * on each matching DB handle.
  89.  *
  90.  * Each cursor is single-threaded, so we only need to lock the
  91.  * list of DBs and then the list of cursors in each DB.
  92.  */
  93. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  94. for (count = 0, ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  95.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  96.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  97. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  98. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  99.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  100. cp = (BTREE_CURSOR *)dbc->internal;
  101. if (cp->pgno == pgno && cp->indx == indx) {
  102. if (delete)
  103. F_SET(cp, C_DELETED);
  104. else
  105. F_CLR(cp, C_DELETED);
  106. ++count;
  107. }
  108. }
  109. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  110. }
  111. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  113. return (count);
  114. }
  116. /*
  117.  * __ram_ca_delete --
  118.  * Return the number of relevant cursors.
  119.  *
  120.  * PUBLIC: int __ram_ca_delete __P((DB *, db_pgno_t));
  121.  */
  122. int
  123. __ram_ca_delete(dbp, root_pgno)
  124. DB *dbp;
  125. db_pgno_t root_pgno;
  126. {
  127. DB *ldbp;
  128. DBC *dbc;
  129. DB_ENV *dbenv;
  130. int found;
  132. found = 0;
  133. dbenv = dbp->dbenv;
  135. /*
  136.  * Review the cursors.  See the comment in __bam_ca_delete().
  137.  */
  138. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  139. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  140.     found == 0 && ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  141.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  142. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  143. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  144.     found == 0 && dbc != NULL; dbc = TAILQ_NEXT(dbc, links))
  145. if (dbc->internal->root == root_pgno)
  146. found = 1;
  147. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  148. }
  149. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  150. return (found);
  151. }
  153. /*
  154.  * __bam_ca_di --
  155.  * Adjust the cursors during a delete or insert.
  156.  *
  157.  * PUBLIC: int __bam_ca_di __P((DBC *, db_pgno_t, u_int32_t, int));
  158.  */
  159. int
  160. __bam_ca_di(my_dbc, pgno, indx, adjust)
  161. DBC *my_dbc;
  162. db_pgno_t pgno;
  163. u_int32_t indx;
  164. int adjust;
  165. {
  166. DB *dbp, *ldbp;
  167. DB_ENV *dbenv;
  168. DB_LSN lsn;
  169. DB_TXN *my_txn;
  170. DBC *dbc;
  171. DBC_INTERNAL *cp;
  172. int found, ret;
  174. dbp = my_dbc->dbp;
  175. dbenv = dbp->dbenv;
  177. my_txn = IS_SUBTRANSACTION(my_dbc->txn) ? my_dbc->txn : NULL;
  179. /*
  180.  * Adjust the cursors.  See the comment in __bam_ca_delete().
  181.  */
  182. found = 0;
  183. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  184. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  185.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  186.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  187. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  188. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  189.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  190. if (dbc->dbtype == DB_RECNO)
  191. continue;
  192. cp = dbc->internal;
  193. if (cp->pgno == pgno && cp->indx >= indx) {
  194. /* Cursor indices should never be negative. */
  195. DB_ASSERT(cp->indx != 0 || adjust > 0);
  197. cp->indx += adjust;
  198. if (my_txn != NULL && dbc->txn != my_txn)
  199. found = 1;
  200. }
  201. }
  202. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  203. }
  204. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  206. if (found != 0 && DB_LOGGING(my_dbc)) {
  207. if ((ret = __bam_curadj_log(dbenv,
  208.     my_dbc->txn, &lsn, 0, dbp->log_fileid,
  209.     DB_CA_DI, pgno, 0, 0, adjust, indx, 0)) != 0)
  210. return (ret);
  211. }
  213. return (0);
  214. }
  216. /*
  217.  * __bam_opd_cursor -- create a new opd cursor.
  218.  */
  219. static int
  220. __bam_opd_cursor(dbp, dbc, first, tpgno, ti)
  221. DB *dbp;
  222. DBC *dbc;
  223. db_pgno_t tpgno;
  224. u_int32_t first, ti;
  225. {
  226. BTREE_CURSOR *cp, *orig_cp;
  227. DBC *dbc_nopd;
  228. int ret;
  230. orig_cp = (BTREE_CURSOR *)dbc->internal;
  231. dbc_nopd = NULL;
  233. /*
  234.  * Allocate a new cursor and create the stack.  If duplicates
  235.  * are sorted, we've just created an off-page duplicate Btree.
  236.  * If duplicates aren't sorted, we've just created a Recno tree.
  237.  */
  238. if ((ret = __db_c_newopd(dbc, tpgno, &dbc_nopd)) != 0)
  239. return (ret);
  241. cp = (BTREE_CURSOR *)dbc_nopd->internal;
  242. cp->pgno = tpgno;
  243. cp->indx = ti;
  245. if (dbp->dup_compare == NULL) {
  246. /*
  247.  * Converting to off-page Recno trees is tricky.  The
  248.  * record number for the cursor is the index + 1 (to
  249.  * convert to 1-based record numbers).
  250.  */
  251. cp->recno = ti + 1;
  252. }
  254. /*
  255.  * Transfer the deleted flag from the top-level cursor to the
  256.  * created one.
  257.  */
  258. if (F_ISSET(orig_cp, C_DELETED)) {
  259. F_SET(cp, C_DELETED);
  260. F_CLR(orig_cp, C_DELETED);
  261. }
  263. /* Stack the cursors and reset the initial cursor's index. */
  264. orig_cp->opd = dbc_nopd;
  265. orig_cp->indx = first;
  266. return (0);
  267. }
  269. /*
  270.  * __bam_ca_dup --
  271.  * Adjust the cursors when moving items from a leaf page to a duplicates
  272.  * page.
  273.  *
  274.  * PUBLIC: int __bam_ca_dup __P((DBC *,
  275.  * PUBLIC:    u_int32_t, db_pgno_t, u_int32_t, db_pgno_t, u_int32_t));
  276.  */
  277. int
  278. __bam_ca_dup(my_dbc, first, fpgno, fi, tpgno, ti)
  279. DBC *my_dbc;
  280. db_pgno_t fpgno, tpgno;
  281. u_int32_t first, fi, ti;
  282. {
  283. BTREE_CURSOR *orig_cp;
  284. DB *dbp, *ldbp;
  285. DBC *dbc;
  286. DB_ENV *dbenv;
  287. DB_LSN lsn;
  288. DB_TXN *my_txn;
  289. int found, ret;
  291. dbp = my_dbc->dbp;
  292. dbenv = dbp->dbenv;
  293. my_txn = IS_SUBTRANSACTION(my_dbc->txn) ? my_dbc->txn : NULL;
  295. /*
  296.  * Adjust the cursors.  See the comment in __bam_ca_delete().
  297.  */
  298. found = 0;
  299. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  300. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  301.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  302.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  303. loop: MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  304. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  305.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  306. /* Find cursors pointing to this record. */
  307. orig_cp = (BTREE_CURSOR *)dbc->internal;
  308. if (orig_cp->pgno != fpgno || orig_cp->indx != fi)
  309. continue;
  311. /*
  312.  * Since we rescan the list see if this is already
  313.  * converted.
  314.  */
  315. if (orig_cp->opd != NULL)
  316. continue;
  318. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  319. if ((ret = __bam_opd_cursor(dbp,
  320.     dbc, first, tpgno, ti)) !=0)
  321. return (ret);
  322. if (my_txn != NULL && dbc->txn != my_txn)
  323. found = 1;
  324. /* We released the MUTEX to get a cursor, start over. */
  325. goto loop;
  326. }
  327. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  328. }
  329. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  331. if (found != 0 && DB_LOGGING(my_dbc)) {
  332. if ((ret = __bam_curadj_log(dbenv,
  333.     my_dbc->txn, &lsn, 0, dbp->log_fileid,
  334.     DB_CA_DUP, fpgno, tpgno, 0, first, fi, ti)) != 0)
  335. return (ret);
  336. }
  337. return (0);
  338. }
  340. /*
  341.  * __bam_ca_undodup --
  342.  * Adjust the cursors when returning items to a leaf page
  343.  * from a duplicate page.
  344.  * Called only during undo processing.
  345.  *
  346.  * PUBLIC: int __bam_ca_undodup __P((DB *,
  347.  * PUBLIC:    u_int32_t, db_pgno_t, u_int32_t, u_int32_t));
  348.  */
  349. int
  350. __bam_ca_undodup(dbp, first, fpgno, fi, ti)
  351. DB *dbp;
  352. db_pgno_t fpgno;
  353. u_int32_t first, fi, ti;
  354. {
  355. BTREE_CURSOR *orig_cp;
  356. DB *ldbp;
  357. DBC *dbc;
  358. DB_ENV *dbenv;
  359. int ret;
  361. dbenv = dbp->dbenv;
  363. /*
  364.  * Adjust the cursors.  See the comment in __bam_ca_delete().
  365.  */
  366. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  367. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  368.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  369.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  370. loop: MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  371. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  372.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  373. orig_cp = (BTREE_CURSOR *)dbc->internal;
  375. if (orig_cp->pgno != fpgno ||
  376.     orig_cp->indx != first ||
  377.     ((BTREE_CURSOR *)orig_cp->opd->internal)->indx
  378.     != ti)
  379. continue;
  380. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  381. if ((ret = orig_cp->opd->c_close(orig_cp->opd)) != 0)
  382. return (ret);
  383. orig_cp->opd = NULL;
  384. orig_cp->indx = fi;
  385. /*
  386.  * We released the MUTEX to free a cursor,
  387.  * start over.
  388.  */
  389. goto loop;
  390. }
  391. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  392. }
  393. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  395. return (0);
  396. }
  398. /*
  399.  * __bam_ca_rsplit --
  400.  * Adjust the cursors when doing reverse splits.
  401.  *
  402.  * PUBLIC: int __bam_ca_rsplit __P((DBC *, db_pgno_t, db_pgno_t));
  403.  */
  404. int
  405. __bam_ca_rsplit(my_dbc, fpgno, tpgno)
  406. DBC* my_dbc;
  407. db_pgno_t fpgno, tpgno;
  408. {
  409. DB *dbp, *ldbp;
  410. DBC *dbc;
  411. DB_ENV *dbenv;
  412. DB_LSN lsn;
  413. DB_TXN *my_txn;
  414. int found, ret;
  416. dbp = my_dbc->dbp;
  417. dbenv = dbp->dbenv;
  418. my_txn = IS_SUBTRANSACTION(my_dbc->txn) ? my_dbc->txn : NULL;
  420. /*
  421.  * Adjust the cursors.  See the comment in __bam_ca_delete().
  422.  */
  423. found = 0;
  424. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  425. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  426.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  427.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  428. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  429. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  430.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  431. if (dbc->dbtype == DB_RECNO)
  432. continue;
  433. if (dbc->internal->pgno == fpgno) {
  434. dbc->internal->pgno = tpgno;
  435. if (my_txn != NULL && dbc->txn != my_txn)
  436. found = 1;
  437. }
  438. }
  439. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  440. }
  441. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  443. if (found != 0 && DB_LOGGING(my_dbc)) {
  444. if ((ret = __bam_curadj_log(dbenv,
  445.     my_dbc->txn, &lsn, 0, dbp->log_fileid,
  446.     DB_CA_RSPLIT, fpgno, tpgno, 0, 0, 0, 0)) != 0)
  447. return (ret);
  448. }
  449. return (0);
  450. }
  452. /*
  453.  * __bam_ca_split --
  454.  * Adjust the cursors when splitting a page.
  455.  *
  456.  * PUBLIC: int __bam_ca_split __P((DBC *,
  457.  * PUBLIC:    db_pgno_t, db_pgno_t, db_pgno_t, u_int32_t, int));
  458.  */
  459. int
  460. __bam_ca_split(my_dbc, ppgno, lpgno, rpgno, split_indx, cleft)
  461. DBC *my_dbc;
  462. db_pgno_t ppgno, lpgno, rpgno;
  463. u_int32_t split_indx;
  464. int cleft;
  465. {
  466. DB *dbp, *ldbp;
  467. DBC *dbc;
  468. DBC_INTERNAL *cp;
  469. DB_ENV *dbenv;
  470. DB_LSN lsn;
  471. DB_TXN *my_txn;
  472. int found, ret;
  474. dbp = my_dbc->dbp;
  475. dbenv = dbp->dbenv;
  476. my_txn = IS_SUBTRANSACTION(my_dbc->txn) ? my_dbc->txn : NULL;
  478. /*
  479.  * Adjust the cursors.  See the comment in __bam_ca_delete().
  480.  *
  481.  * If splitting the page that a cursor was on, the cursor has to be
  482.  * adjusted to point to the same record as before the split.  Most
  483.  * of the time we don't adjust pointers to the left page, because
  484.  * we're going to copy its contents back over the original page.  If
  485.  * the cursor is on the right page, it is decremented by the number of
  486.  * records split to the left page.
  487.  */
  488. found = 0;
  489. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  490. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  491.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  492.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  493. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  494. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  495.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  496. if (dbc->dbtype == DB_RECNO)
  497. continue;
  498. cp = dbc->internal;
  499. if (cp->pgno == ppgno) {
  500. if (my_txn != NULL && dbc->txn != my_txn)
  501. found = 1;
  502. if (cp->indx < split_indx) {
  503. if (cleft)
  504. cp->pgno = lpgno;
  505. } else {
  506. cp->pgno = rpgno;
  507. cp->indx -= split_indx;
  508. }
  509. }
  510. }
  511. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  512. }
  513. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  515. if (found != 0 && DB_LOGGING(my_dbc)) {
  516. if ((ret = __bam_curadj_log(dbenv, my_dbc->txn,
  517.     &lsn, 0, dbp->log_fileid, DB_CA_SPLIT, ppgno, rpgno,
  518.     cleft ? lpgno : PGNO_INVALID, 0, split_indx, 0)) != 0)
  519. return (ret);
  520. }
  522. return (0);
  523. }
  525. /*
  526.  * __bam_ca_undosplit --
  527.  * Adjust the cursors when undoing a split of a page.
  528.  * If we grew a level we will execute this for both the
  529.  * left and the right pages.
  530.  * Called only during undo processing.
  531.  *
  532.  * PUBLIC: void __bam_ca_undosplit __P((DB *,
  533.  * PUBLIC:    db_pgno_t, db_pgno_t, db_pgno_t, u_int32_t));
  534.  */
  535. void
  536. __bam_ca_undosplit(dbp, frompgno, topgno, lpgno, split_indx)
  537. DB *dbp;
  538. db_pgno_t frompgno, topgno, lpgno;
  539. u_int32_t split_indx;
  540. {
  541. DB *ldbp;
  542. DBC *dbc;
  543. DB_ENV *dbenv;
  544. DBC_INTERNAL *cp;
  546. dbenv = dbp->dbenv;
  548. /*
  549.  * Adjust the cursors.  See the comment in __bam_ca_delete().
  550.  *
  551.  * When backing out a split, we move the cursor back
  552.  * to the original offset and bump it by the split_indx.
  553.  */
  554. MUTEX_THREAD_LOCK(dbenv, dbenv->dblist_mutexp);
  555. for (ldbp = __dblist_get(dbenv, dbp->adj_fileid);
  556.     ldbp != NULL && ldbp->adj_fileid == dbp->adj_fileid;
  557.     ldbp = LIST_NEXT(ldbp, dblistlinks)) {
  558. MUTEX_THREAD_LOCK(dbenv, dbp->mutexp);
  559. for (dbc = TAILQ_FIRST(&ldbp->active_queue);
  560.     dbc != NULL; dbc = TAILQ_NEXT(dbc, links)) {
  561. if (dbc->dbtype == DB_RECNO)
  562. continue;
  563. cp = dbc->internal;
  564. if (cp->pgno == topgno) {
  565. cp->pgno = frompgno;
  566. cp->indx += split_indx;
  567. } else if (cp->pgno == lpgno)
  568. cp->pgno = frompgno;
  569. }
  570. MUTEX_THREAD_UNLOCK(dbenv, dbp->mutexp);
  571. }
  572. MUTEX_THREAD_UNLOCK(dbenv, dbenv->dblist_mutexp);
  573. }