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

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

MySQL数据库

开发平台：

Visual C++

db_upg_opd.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: db_upg_opd.c,v 11.18 2002/08/06 06:11:18 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/btree.h"
  24. static int __db_build_bi __P((DB *, DB_FH *, PAGE *, PAGE *, u_int32_t, int *));
  25. static int __db_build_ri __P((DB *, DB_FH *, PAGE *, PAGE *, u_int32_t, int *));
  26. static int __db_up_ovref __P((DB *, DB_FH *, db_pgno_t));
  28. #define GET_PAGE(dbp, fhp, pgno, page) {
  29. if ((ret = __os_seek(dbp->dbenv,
  30.     fhp, (dbp)->pgsize, pgno, 0, 0, DB_OS_SEEK_SET)) != 0)
  31. goto err;
  32. if ((ret = __os_read(dbp->dbenv,
  33.     fhp, page, (dbp)->pgsize, &n)) != 0)
  34. goto err;
  35. }
  36. #define PUT_PAGE(dbp, fhp, pgno, page) {
  37. if ((ret = __os_seek(dbp->dbenv,
  38.     fhp, (dbp)->pgsize, pgno, 0, 0, DB_OS_SEEK_SET)) != 0)
  39. goto err;
  40. if ((ret = __os_write(dbp->dbenv,
  41.     fhp, page, (dbp)->pgsize, &n)) != 0)
  42. goto err;
  43. }
  45. /*
  46.  * __db_31_offdup --
  47.  * Convert 3.0 off-page duplicates to 3.1 off-page duplicates.
  48.  *
  49.  * PUBLIC: int __db_31_offdup __P((DB *, char *, DB_FH *, int, db_pgno_t *));
  50.  */
  51. int
  52. __db_31_offdup(dbp, real_name, fhp, sorted, pgnop)
  53. DB *dbp;
  54. char *real_name;
  55. DB_FH *fhp;
  56. int sorted;
  57. db_pgno_t *pgnop;
  58. {
  59. PAGE *ipage, *page;
  60. db_indx_t indx;
  61. db_pgno_t cur_cnt, i, next_cnt, pgno, *pgno_cur, pgno_last;
  62. db_pgno_t *pgno_next, pgno_max, *tmp;
  63. db_recno_t nrecs;
  64. size_t n;
  65. int level, nomem, ret;
  67. ipage = page = NULL;
  68. pgno_cur = pgno_next = NULL;
  70. /* Allocate room to hold a page. */
  71. if ((ret = __os_malloc(dbp->dbenv, dbp->pgsize, &page)) != 0)
  72. goto err;
  74. /*
  75.  * Walk the chain of 3.0 off-page duplicates.  Each one is converted
  76.  * in place to a 3.1 off-page duplicate page.  If the duplicates are
  77.  * sorted, they are converted to a Btree leaf page, otherwise to a
  78.  * Recno leaf page.
  79.  */
  80. for (nrecs = 0, cur_cnt = pgno_max = 0,
  81.     pgno = *pgnop; pgno != PGNO_INVALID;) {
  82. if (pgno_max == cur_cnt) {
  83. pgno_max += 20;
  84. if ((ret = __os_realloc(dbp->dbenv, pgno_max *
  85.     sizeof(db_pgno_t), &pgno_cur)) != 0)
  86. goto err;
  87. }
  88. pgno_cur[cur_cnt++] = pgno;
  90. GET_PAGE(dbp, fhp, pgno, page);
  91. nrecs += NUM_ENT(page);
  92. LEVEL(page) = LEAFLEVEL;
  93. TYPE(page) = sorted ? P_LDUP : P_LRECNO;
  94. /*
  95.  * !!!
  96.  * DB didn't zero the LSNs on off-page duplicates pages.
  97.  */
  98. ZERO_LSN(LSN(page));
  99. PUT_PAGE(dbp, fhp, pgno, page);
  101. pgno = NEXT_PGNO(page);
  102. }
  104. /* If we only have a single page, it's easy. */
  105. if (cur_cnt > 1) {
  106. /*
  107.  * pgno_cur is the list of pages we just converted.  We're
  108.  * going to walk that list, but we'll need to create a new
  109.  * list while we do so.
  110.  */
  111. if ((ret = __os_malloc(dbp->dbenv,
  112.     cur_cnt * sizeof(db_pgno_t), &pgno_next)) != 0)
  113. goto err;
  115. /* Figure out where we can start allocating new pages. */
  116. if ((ret = __db_lastpgno(dbp, real_name, fhp, &pgno_last)) != 0)
  117. goto err;
  119. /* Allocate room for an internal page. */
  120. if ((ret = __os_malloc(dbp->dbenv,
  121.     dbp->pgsize, &ipage)) != 0)
  122. goto err;
  123. PGNO(ipage) = PGNO_INVALID;
  124. }
  126. /*
  127.  * Repeatedly walk the list of pages, building internal pages, until
  128.  * there's only one page at a level.
  129.  */
  130. for (level = LEAFLEVEL + 1; cur_cnt > 1; ++level) {
  131. for (indx = 0, i = next_cnt = 0; i < cur_cnt;) {
  132. if (indx == 0) {
  133. P_INIT(ipage, dbp->pgsize, pgno_last,
  134.     PGNO_INVALID, PGNO_INVALID,
  135.     level, sorted ? P_IBTREE : P_IRECNO);
  136. ZERO_LSN(LSN(ipage));
  138. pgno_next[next_cnt++] = pgno_last++;
  139. }
  141. GET_PAGE(dbp, fhp, pgno_cur[i], page);
  143. /*
  144.  * If the duplicates are sorted, put the first item on
  145.  * the lower-level page onto a Btree internal page. If
  146.  * the duplicates are not sorted, create an internal
  147.  * Recno structure on the page.  If either case doesn't
  148.  * fit, push out the current page and start a new one.
  149.  */
  150. nomem = 0;
  151. if (sorted) {
  152. if ((ret = __db_build_bi(
  153.     dbp, fhp, ipage, page, indx, &nomem)) != 0)
  154. goto err;
  155. } else
  156. if ((ret = __db_build_ri(
  157.     dbp, fhp, ipage, page, indx, &nomem)) != 0)
  158. goto err;
  159. if (nomem) {
  160. indx = 0;
  161. PUT_PAGE(dbp, fhp, PGNO(ipage), ipage);
  162. } else {
  163. ++indx;
  164. ++NUM_ENT(ipage);
  165. ++i;
  166. }
  167. }
  169. /*
  170.  * Push out the last internal page.  Set the top-level record
  171.  * count if we've reached the top.
  172.  */
  173. if (next_cnt == 1)
  174. RE_NREC_SET(ipage, nrecs);
  175. PUT_PAGE(dbp, fhp, PGNO(ipage), ipage);
  177. /* Swap the current and next page number arrays. */
  178. cur_cnt = next_cnt;
  179. tmp = pgno_cur;
  180. pgno_cur = pgno_next;
  181. pgno_next = tmp;
  182. }
  184. *pgnop = pgno_cur[0];
  186. err: if (pgno_cur != NULL)
  187. __os_free(dbp->dbenv, pgno_cur);
  188. if (pgno_next != NULL)
  189. __os_free(dbp->dbenv, pgno_next);
  190. if (ipage != NULL)
  191. __os_free(dbp->dbenv, ipage);
  192. if (page != NULL)
  193. __os_free(dbp->dbenv, page);
  195. return (ret);
  196. }
  198. /*
  199.  * __db_build_bi --
  200.  * Build a BINTERNAL entry for a parent page.
  201.  */
  202. static int
  203. __db_build_bi(dbp, fhp, ipage, page, indx, nomemp)
  204. DB *dbp;
  205. DB_FH *fhp;
  206. PAGE *ipage, *page;
  207. u_int32_t indx;
  208. int *nomemp;
  209. {
  210. BINTERNAL bi, *child_bi;
  211. BKEYDATA *child_bk;
  212. u_int8_t *p;
  213. int ret;
  214. db_indx_t *inp;
  216. inp = P_INP(dbp, ipage);
  217. switch (TYPE(page)) {
  218. case P_IBTREE:
  219. child_bi = GET_BINTERNAL(dbp, page, 0);
  220. if (P_FREESPACE(dbp, ipage) < BINTERNAL_PSIZE(child_bi->len)) {
  221. *nomemp = 1;
  222. return (0);
  223. }
  224. inp[indx] =
  225.     HOFFSET(ipage) -= BINTERNAL_SIZE(child_bi->len);
  226. p = P_ENTRY(dbp, ipage, indx);
  228. bi.len = child_bi->len;
  229. B_TSET(bi.type, child_bi->type, 0);
  230. bi.pgno = PGNO(page);
  231. bi.nrecs = __bam_total(dbp, page);
  232. memcpy(p, &bi, SSZA(BINTERNAL, data));
  233. p += SSZA(BINTERNAL, data);
  234. memcpy(p, child_bi->data, child_bi->len);
  236. /* Increment the overflow ref count. */
  237. if (B_TYPE(child_bi->type) == B_OVERFLOW)
  238. if ((ret = __db_up_ovref(dbp, fhp,
  239.     ((BOVERFLOW *)(child_bi->data))->pgno)) != 0)
  240. return (ret);
  241. break;
  242. case P_LDUP:
  243. child_bk = GET_BKEYDATA(dbp, page, 0);
  244. switch (B_TYPE(child_bk->type)) {
  245. case B_KEYDATA:
  246. if (P_FREESPACE(dbp, ipage) <
  247.     BINTERNAL_PSIZE(child_bk->len)) {
  248. *nomemp = 1;
  249. return (0);
  250. }
  251. inp[indx] =
  252.     HOFFSET(ipage) -= BINTERNAL_SIZE(child_bk->len);
  253. p = P_ENTRY(dbp, ipage, indx);
  255. bi.len = child_bk->len;
  256. B_TSET(bi.type, child_bk->type, 0);
  257. bi.pgno = PGNO(page);
  258. bi.nrecs = __bam_total(dbp, page);
  259. memcpy(p, &bi, SSZA(BINTERNAL, data));
  260. p += SSZA(BINTERNAL, data);
  261. memcpy(p, child_bk->data, child_bk->len);
  262. break;
  263. case B_OVERFLOW:
  264. if (P_FREESPACE(dbp, ipage) <
  265.     BINTERNAL_PSIZE(BOVERFLOW_SIZE)) {
  266. *nomemp = 1;
  267. return (0);
  268. }
  269. inp[indx] =
  270.     HOFFSET(ipage) -= BINTERNAL_SIZE(BOVERFLOW_SIZE);
  271. p = P_ENTRY(dbp, ipage, indx);
  273. bi.len = BOVERFLOW_SIZE;
  274. B_TSET(bi.type, child_bk->type, 0);
  275. bi.pgno = PGNO(page);
  276. bi.nrecs = __bam_total(dbp, page);
  277. memcpy(p, &bi, SSZA(BINTERNAL, data));
  278. p += SSZA(BINTERNAL, data);
  279. memcpy(p, child_bk, BOVERFLOW_SIZE);
  281. /* Increment the overflow ref count. */
  282. if ((ret = __db_up_ovref(dbp, fhp,
  283.     ((BOVERFLOW *)child_bk)->pgno)) != 0)
  284. return (ret);
  285. break;
  286. default:
  287. return (__db_pgfmt(dbp->dbenv, PGNO(page)));
  288. }
  289. break;
  290. default:
  291. return (__db_pgfmt(dbp->dbenv, PGNO(page)));
  292. }
  294. return (0);
  295. }
  297. /*
  298.  * __db_build_ri --
  299.  * Build a RINTERNAL entry for an internal parent page.
  300.  */
  301. static int
  302. __db_build_ri(dbp, fhp, ipage, page, indx, nomemp)
  303. DB *dbp;
  304. DB_FH *fhp;
  305. PAGE *ipage, *page;
  306. u_int32_t indx;
  307. int *nomemp;
  308. {
  309. RINTERNAL ri;
  310. db_indx_t *inp;
  312. COMPQUIET(fhp, NULL);
  313. inp = P_INP(dbp, ipage);
  314. if (P_FREESPACE(dbp, ipage) < RINTERNAL_PSIZE) {
  315. *nomemp = 1;
  316. return (0);
  317. }
  319. ri.pgno = PGNO(page);
  320. ri.nrecs = __bam_total(dbp, page);
  321. inp[indx] = HOFFSET(ipage) -= RINTERNAL_SIZE;
  322. memcpy(P_ENTRY(dbp, ipage, indx), &ri, RINTERNAL_SIZE);
  324. return (0);
  325. }
  327. /*
  328.  * __db_up_ovref --
  329.  * Increment/decrement the reference count on an overflow page.
  330.  */
  331. static int
  332. __db_up_ovref(dbp, fhp, pgno)
  333. DB *dbp;
  334. DB_FH *fhp;
  335. db_pgno_t pgno;
  336. {
  337. PAGE *page;
  338. size_t n;
  339. int ret;
  341. /* Allocate room to hold a page. */
  342. if ((ret = __os_malloc(dbp->dbenv, dbp->pgsize, &page)) != 0)
  343. return (ret);
  345. GET_PAGE(dbp, fhp, pgno, page);
  346. ++OV_REF(page);
  347. PUT_PAGE(dbp, fhp, pgno, page);
  349. err: __os_free(dbp->dbenv, page);
  351. return (ret);
  352. }