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

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

MySQL数据库

开发平台：

Visual C++

db_page.h：源码内容
  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.  *
  7.  * $Id: db_page.h,v 11.28 2000/12/06 19:55:45 ubell Exp $
  8.  */
  10. #ifndef _DB_PAGE_H_
  11. #define _DB_PAGE_H_
  13. #if defined(__cplusplus)
  14. extern "C" {
  15. #endif
  17. /*
  18.  * DB page formats.
  19.  *
  20.  * !!!
  21.  * This implementation requires that values within the following structures
  22.  * NOT be padded -- note, ANSI C permits random padding within structures.
  23.  * If your compiler pads randomly you can just forget ever making DB run on
  24.  * your system.  In addition, no data type can require larger alignment than
  25.  * its own size, e.g., a 4-byte data element may not require 8-byte alignment.
  26.  *
  27.  * Note that key/data lengths are often stored in db_indx_t's -- this is
  28.  * not accidental, nor does it limit the key/data size.  If the key/data
  29.  * item fits on a page, it's guaranteed to be small enough to fit into a
  30.  * db_indx_t, and storing it in one saves space.
  31.  */
  33. #define PGNO_INVALID 0 /* Invalid page number in any database. */
  34. #define PGNO_BASE_MD 0 /* Base database: metadata page number. */
  36. /* Page types. */
  37. #define P_INVALID 0 /* Invalid page type. */
  38. #define __P_DUPLICATE 1 /* Duplicate. DEPRECATED in 3.1 */
  39. #define P_HASH 2 /* Hash. */
  40. #define P_IBTREE 3 /* Btree internal. */
  41. #define P_IRECNO 4 /* Recno internal. */
  42. #define P_LBTREE 5 /* Btree leaf. */
  43. #define P_LRECNO 6 /* Recno leaf. */
  44. #define P_OVERFLOW 7 /* Overflow. */
  45. #define P_HASHMETA 8 /* Hash metadata page. */
  46. #define P_BTREEMETA 9 /* Btree metadata page. */
  47. #define P_QAMMETA 10 /* Queue metadata page. */
  48. #define P_QAMDATA 11 /* Queue data page. */
  49. #define P_LDUP 12 /* Off-page duplicate leaf. */
  50. #define P_PAGETYPE_MAX 13
  52. /*
  53.  * When we create pages in mpool, we ask mpool to clear some number of bytes
  54.  * in the header.  This number must be at least as big as the regular page
  55.  * headers and cover enough of the btree and hash meta-data pages to obliterate
  56.  * the page type.
  57.  */
  58. #define DB_PAGE_DB_LEN 32
  59. #define DB_PAGE_QUEUE_LEN 0
  61. /************************************************************************
  62.  GENERIC METADATA PAGE HEADER
  63.  *
  64.  * !!!
  65.  * The magic and version numbers have to be in the same place in all versions
  66.  * of the metadata page as the application may not have upgraded the database.
  67.  ************************************************************************/
  68. typedef struct _dbmeta31 {
  69. DB_LSN   lsn; /* 00-07: LSN. */
  70. db_pgno_t pgno; /* 08-11: Current page number. */
  71. u_int32_t magic; /* 12-15: Magic number. */
  72. u_int32_t version; /* 16-19: Version. */
  73. u_int32_t pagesize; /* 20-23: Pagesize. */
  74. u_int8_t  unused1[1]; /*    24: Unused. */
  75. u_int8_t  type; /*    25: Page type. */
  76. u_int8_t  unused2[2]; /* 26-27: Unused. */
  77. u_int32_t free; /* 28-31: Free list page number. */
  78. DB_LSN   unused3; /* 32-39: former Lsn for allocation */
  79. u_int32_t key_count; /* 40-43: Cached key count. */
  80. u_int32_t record_count; /* 44-47: Cached record count. */
  81. u_int32_t flags; /* 48-51: Flags: unique to each AM. */
  82. /* 52-71: Unique file ID. */
  83. u_int8_t  uid[DB_FILE_ID_LEN];
  84. } DBMETA31, DBMETA;
  86. /************************************************************************
  87.  BTREE METADATA PAGE LAYOUT
  88.  ************************************************************************/
  89. typedef struct _btmeta31 {
  90. #define BTM_DUP 0x001 /*   Duplicates. */
  91. #define BTM_RECNO 0x002 /*   Recno tree. */
  92. #define BTM_RECNUM 0x004 /*   Btree: maintain record count. */
  93. #define BTM_FIXEDLEN 0x008 /*   Recno: fixed length records. */
  94. #define BTM_RENUMBER 0x010 /*   Recno: renumber on insert/delete. */
  95. #define BTM_SUBDB 0x020 /*   Subdatabases. */
  96. #define BTM_DUPSORT 0x040 /*   Duplicates are sorted. */
  97. #define BTM_MASK 0x07f
  98. DBMETA dbmeta; /* 00-71: Generic meta-data header. */
  100. u_int32_t maxkey; /* 72-75: Btree: Maxkey. */
  101. u_int32_t minkey; /* 76-79: Btree: Minkey. */
  102. u_int32_t re_len; /* 80-83: Recno: fixed-length record length. */
  103. u_int32_t re_pad; /* 84-87: Recno: fixed-length record pad. */
  104. u_int32_t root; /* 88-92: Root page. */
  106. /*
  107.  * Minimum page size is 128.
  108.  */
  109. } BTMETA31, BTMETA;
  111. /************************************************************************
  112.  HASH METADATA PAGE LAYOUT
  113.  ************************************************************************/
  114. typedef struct _hashmeta31 {
  115. #define DB_HASH_DUP 0x01 /*   Duplicates. */
  116. #define DB_HASH_SUBDB 0x02 /*   Subdatabases. */
  117. #define DB_HASH_DUPSORT 0x04 /*   Duplicates are sorted. */
  118. DBMETA dbmeta; /* 00-71: Generic meta-data page header. */
  120. u_int32_t max_bucket; /* 72-75: ID of Maximum bucket in use */
  121. u_int32_t high_mask; /* 76-79: Modulo mask into table */
  122. u_int32_t low_mask; /* 80-83: Modulo mask into table lower half */
  123. u_int32_t ffactor; /* 84-87: Fill factor */
  124. u_int32_t nelem; /* 88-91: Number of keys in hash table */
  125. u_int32_t h_charkey; /* 92-95: Value of hash(CHARKEY) */
  126. #define NCACHED 32 /* number of spare points */
  127. /* 96-223: Spare pages for overflow */
  128. u_int32_t spares[NCACHED];
  130. /*
  131.  * Minimum page size is 256.
  132.  */
  133. } HMETA31, HMETA;
  135. /************************************************************************
  136.  QUEUE METADATA PAGE LAYOUT
  137.  ************************************************************************/
  138. /*
  139.  * QAM Meta data page structure
  140.  *
  141.  */
  142. typedef struct _qmeta32 {
  143. DBMETA    dbmeta; /* 00-71: Generic meta-data header. */
  145. u_int32_t first_recno; /* 72-75: First not deleted record. */
  146. u_int32_t cur_recno; /* 76-79: Last recno allocated. */
  147. u_int32_t re_len; /* 80-83: Fixed-length record length. */
  148. u_int32_t re_pad; /* 84-87: Fixed-length record pad. */
  149. u_int32_t rec_page; /* 88-91: Records Per Page. */
  150. u_int32_t page_ext; /* 92-95: Pages per extent */
  152. /*
  153.  * Minimum page size is 128.
  154.  */
  155. } QMETA32, QMETA;
  157. /*
  158.  * DBMETASIZE is a constant used by __db_file_setup and DB->verify
  159.  * as a buffer which is guaranteed to be larger than any possible
  160.  * metadata page size and smaller than any disk sector.
  161.  */
  162. #define DBMETASIZE 256
  164. /************************************************************************
  165.  BTREE/HASH MAIN PAGE LAYOUT
  166.  ************************************************************************/
  167. /*
  168.  * +-----------------------------------+
  169.  * |    lsn    |   pgno    | prev pgno |
  170.  * +-----------------------------------+
  171.  * | next pgno |  entries  | hf offset |
  172.  * +-----------------------------------+
  173.  * |   level   |   type    |   index   |
  174.  * +-----------------------------------+
  175.  * |   index   | free -->              |
  176.  * +-----------+-----------------------+
  177.  * |  F R E E A R E A            |
  178.  * +-----------------------------------+
  179.  * |              <-- free |   item    |
  180.  * +-----------------------------------+
  181.  * |   item    |   item    |   item    |
  182.  * +-----------------------------------+
  183.  *
  184.  * sizeof(PAGE) == 26 bytes, and the following indices are guaranteed to be
  185.  * two-byte aligned.
  186.  *
  187.  * For hash and btree leaf pages, index items are paired, e.g., inp[0] is the
  188.  * key for inp[1]'s data.  All other types of pages only contain single items.
  189.  */
  190. typedef struct _db_page {
  191. DB_LSN   lsn; /* 00-07: Log sequence number. */
  192. db_pgno_t pgno; /* 08-11: Current page number. */
  193. db_pgno_t prev_pgno; /* 12-15: Previous page number. */
  194. db_pgno_t next_pgno; /* 16-19: Next page number. */
  195. db_indx_t entries; /* 20-21: Number of items on the page. */
  196. db_indx_t hf_offset; /* 22-23: High free byte page offset. */
  198. /*
  199.  * The btree levels are numbered from the leaf to the root, starting
  200.  * with 1, so the leaf is level 1, its parent is level 2, and so on.
  201.  * We maintain this level on all btree pages, but the only place that
  202.  * we actually need it is on the root page.  It would not be difficult
  203.  * to hide the byte on the root page once it becomes an internal page,
  204.  * so we could get this byte back if we needed it for something else.
  205.  */
  206. #define LEAFLEVEL   1
  207. #define MAXBTREELEVEL 255
  208. u_int8_t  level; /*    24: Btree tree level. */
  209. u_int8_t  type; /*    25: Page type. */
  210. db_indx_t inp[1]; /* Variable length index of items. */
  211. } PAGE;
  213. /* PAGE element macros. */
  214. #define LSN(p) (((PAGE *)p)->lsn)
  215. #define PGNO(p) (((PAGE *)p)->pgno)
  216. #define PREV_PGNO(p) (((PAGE *)p)->prev_pgno)
  217. #define NEXT_PGNO(p) (((PAGE *)p)->next_pgno)
  218. #define NUM_ENT(p) (((PAGE *)p)->entries)
  219. #define HOFFSET(p) (((PAGE *)p)->hf_offset)
  220. #define LEVEL(p) (((PAGE *)p)->level)
  221. #define TYPE(p) (((PAGE *)p)->type)
  223. /************************************************************************
  224.  QUEUE MAIN PAGE LAYOUT
  225.  ************************************************************************/
  226. typedef struct _qpage {
  227. DB_LSN   lsn; /* 00-07: Log sequence number. */
  228. db_pgno_t pgno; /* 08-11: Current page number. */
  229. u_int32_t unused0[3]; /* 12-23: Unused. */
  230. u_int8_t  unused1[1]; /*    24: Unused. */
  231. u_int8_t  type; /*    25: Page type. */
  232. u_int8_t  unused2[2]; /* 26-27: Unused. */
  233. } QPAGE;
  235. /*
  236.  * !!!
  237.  * The next_pgno and prev_pgno fields are not maintained for btree and recno
  238.  * internal pages.  Doing so only provides a minor performance improvement,
  239.  * it's hard to do when deleting internal pages, and it increases the chance
  240.  * of deadlock during deletes and splits because we have to re-link pages at
  241.  * more than the leaf level.
  242.  *
  243.  * !!!
  244.  * The btree/recno access method needs db_recno_t bytes of space on the root
  245.  * page to specify how many records are stored in the tree.  (The alternative
  246.  * is to store the number of records in the meta-data page, which will create
  247.  * a second hot spot in trees being actively modified, or recalculate it from
  248.  * the BINTERNAL fields on each access.)  Overload the PREV_PGNO field.
  249.  */
  250. #define RE_NREC(p)
  251. ((TYPE(p) == P_IBTREE || TYPE(p) == P_IRECNO) ?
  252. PREV_PGNO(p) : (TYPE(p) == P_LBTREE ? NUM_ENT(p) / 2 : NUM_ENT(p)))
  253. #define RE_NREC_ADJ(p, adj)
  254. PREV_PGNO(p) += adj;
  255. #define RE_NREC_SET(p, num)
  256. PREV_PGNO(p) = num;
  258. /*
  259.  * Initialize a page.
  260.  *
  261.  * !!!
  262.  * Don't modify the page's LSN, code depends on it being unchanged after a
  263.  * P_INIT call.
  264.  */
  265. #define P_INIT(pg, pg_size, n, pg_prev, pg_next, btl, pg_type) do {
  266. PGNO(pg) = n;
  267. PREV_PGNO(pg) = pg_prev;
  268. NEXT_PGNO(pg) = pg_next;
  269. NUM_ENT(pg) = 0;
  270. HOFFSET(pg) = pg_size;
  271. LEVEL(pg) = btl;
  272. TYPE(pg) = pg_type;
  273. } while (0)
  275. /* Page header length (offset to first index). */
  276. #define P_OVERHEAD (SSZA(PAGE, inp))
  278. /* First free byte. */
  279. #define LOFFSET(pg) (P_OVERHEAD + NUM_ENT(pg) * sizeof(db_indx_t))
  281. /* Free space on a regular page. */
  282. #define P_FREESPACE(pg) (HOFFSET(pg) - LOFFSET(pg))
  284. /* Get a pointer to the bytes at a specific index. */
  285. #define P_ENTRY(pg, indx) ((u_int8_t *)pg + ((PAGE *)pg)->inp[indx])
  287. /************************************************************************
  288.  OVERFLOW PAGE LAYOUT
  289.  ************************************************************************/
  291. /*
  292.  * Overflow items are referenced by HOFFPAGE and BOVERFLOW structures, which
  293.  * store a page number (the first page of the overflow item) and a length
  294.  * (the total length of the overflow item).  The overflow item consists of
  295.  * some number of overflow pages, linked by the next_pgno field of the page.
  296.  * A next_pgno field of PGNO_INVALID flags the end of the overflow item.
  297.  *
  298.  * Overflow page overloads:
  299.  * The amount of overflow data stored on each page is stored in the
  300.  * hf_offset field.
  301.  *
  302.  * The implementation reference counts overflow items as it's possible
  303.  * for them to be promoted onto btree internal pages.  The reference
  304.  * count is stored in the entries field.
  305.  */
  306. #define OV_LEN(p) (((PAGE *)p)->hf_offset)
  307. #define OV_REF(p) (((PAGE *)p)->entries)
  309. /* Maximum number of bytes that you can put on an overflow page. */
  310. #define P_MAXSPACE(psize) ((psize) - P_OVERHEAD)
  312. /* Free space on an overflow page. */
  313. #define P_OVFLSPACE(psize, pg) (P_MAXSPACE(psize) - HOFFSET(pg))
  315. /************************************************************************
  316.  HASH PAGE LAYOUT
  317.  ************************************************************************/
  319. /* Each index references a group of bytes on the page. */
  320. #define H_KEYDATA 1 /* Key/data item. */
  321. #define H_DUPLICATE 2 /* Duplicate key/data item. */
  322. #define H_OFFPAGE 3 /* Overflow key/data item. */
  323. #define H_OFFDUP 4 /* Overflow page of duplicates. */
  325. /*
  326.  * !!!
  327.  * Items on hash pages are (potentially) unaligned, so we can never cast the
  328.  * (page + offset) pointer to an HKEYDATA, HOFFPAGE or HOFFDUP structure, as
  329.  * we do with B+tree on-page structures.  Because we frequently want the type
  330.  * field, it requires no alignment, and it's in the same location in all three
  331.  * structures, there's a pair of macros.
  332.  */
  333. #define HPAGE_PTYPE(p) (*(u_int8_t *)p)
  334. #define HPAGE_TYPE(pg, indx) (*P_ENTRY(pg, indx))
  336. /*
  337.  * The first and second types are H_KEYDATA and H_DUPLICATE, represented
  338.  * by the HKEYDATA structure:
  339.  *
  340.  * +-----------------------------------+
  341.  * |    type   | key/data ...          |
  342.  * +-----------------------------------+
  343.  *
  344.  * For duplicates, the data field encodes duplicate elements in the data
  345.  * field:
  346.  *
  347.  * +---------------------------------------------------------------+
  348.  * |    type   | len1 | element1 | len1 | len2 | element2 | len2   |
  349.  * +---------------------------------------------------------------+
  350.  *
  351.  * Thus, by keeping track of the offset in the element, we can do both
  352.  * backward and forward traversal.
  353.  */
  354. typedef struct _hkeydata {
  355. u_int8_t  type; /*    00: Page type. */
  356. u_int8_t  data[1]; /* Variable length key/data item. */
  357. } HKEYDATA;
  358. #define HKEYDATA_DATA(p) (((u_int8_t *)p) + SSZA(HKEYDATA, data))
  360. /*
  361.  * The length of any HKEYDATA item. Note that indx is an element index,
  362.  * not a PAIR index.
  363.  */
  364. #define LEN_HITEM(pg, pgsize, indx)
  365. (((indx) == 0 ? pgsize :
  366. ((PAGE *)(pg))->inp[indx - 1]) - ((PAGE *)(pg))->inp[indx])
  368. #define LEN_HKEYDATA(pg, psize, indx)
  369. (LEN_HITEM(pg, psize, indx) - HKEYDATA_SIZE(0))
  371. /*
  372.  * Page space required to add a new HKEYDATA item to the page, with and
  373.  * without the index value.
  374.  */
  375. #define HKEYDATA_SIZE(len)
  376. ((len) + SSZA(HKEYDATA, data))
  377. #define HKEYDATA_PSIZE(len)
  378. (HKEYDATA_SIZE(len) + sizeof(db_indx_t))
  380. /* Put a HKEYDATA item at the location referenced by a page entry. */
  381. #define PUT_HKEYDATA(pe, kd, len, type) {
  382. ((HKEYDATA *)pe)->type = type;
  383. memcpy((u_int8_t *)pe + sizeof(u_int8_t), kd, len);
  384. }
  386. /*
  387.  * Macros the describe the page layout in terms of key-data pairs.
  388.  */
  389. #define H_NUMPAIRS(pg) (NUM_ENT(pg) / 2)
  390. #define H_KEYINDEX(indx) (indx)
  391. #define H_DATAINDEX(indx) ((indx) + 1)
  392. #define H_PAIRKEY(pg, indx) P_ENTRY(pg, H_KEYINDEX(indx))
  393. #define H_PAIRDATA(pg, indx) P_ENTRY(pg, H_DATAINDEX(indx))
  394. #define H_PAIRSIZE(pg, psize, indx)
  395. (LEN_HITEM(pg, psize, H_KEYINDEX(indx)) +
  396. LEN_HITEM(pg, psize, H_DATAINDEX(indx)))
  397. #define LEN_HDATA(p, psize, indx) LEN_HKEYDATA(p, psize, H_DATAINDEX(indx))
  398. #define LEN_HKEY(p, psize, indx) LEN_HKEYDATA(p, psize, H_KEYINDEX(indx))
  400. /*
  401.  * The third type is the H_OFFPAGE, represented by the HOFFPAGE structure:
  402.  */
  403. typedef struct _hoffpage {
  404. u_int8_t  type; /*    00: Page type and delete flag. */
  405. u_int8_t  unused[3]; /* 01-03: Padding, unused. */
  406. db_pgno_t pgno; /* 04-07: Offpage page number. */
  407. u_int32_t tlen; /* 08-11: Total length of item. */
  408. } HOFFPAGE;
  410. #define HOFFPAGE_PGNO(p) (((u_int8_t *)p) + SSZ(HOFFPAGE, pgno))
  411. #define HOFFPAGE_TLEN(p) (((u_int8_t *)p) + SSZ(HOFFPAGE, tlen))
  413. /*
  414.  * Page space required to add a new HOFFPAGE item to the page, with and
  415.  * without the index value.
  416.  */
  417. #define HOFFPAGE_SIZE (sizeof(HOFFPAGE))
  418. #define HOFFPAGE_PSIZE (HOFFPAGE_SIZE + sizeof(db_indx_t))
  420. /*
  421.  * The fourth type is H_OFFDUP represented by the HOFFDUP structure:
  422.  */
  423. typedef struct _hoffdup {
  424. u_int8_t  type; /*    00: Page type and delete flag. */
  425. u_int8_t  unused[3]; /* 01-03: Padding, unused. */
  426. db_pgno_t pgno; /* 04-07: Offpage page number. */
  427. } HOFFDUP;
  428. #define HOFFDUP_PGNO(p) (((u_int8_t *)p) + SSZ(HOFFDUP, pgno))
  430. /*
  431.  * Page space required to add a new HOFFDUP item to the page, with and
  432.  * without the index value.
  433.  */
  434. #define HOFFDUP_SIZE (sizeof(HOFFDUP))
  436. /************************************************************************
  437.  BTREE PAGE LAYOUT
  438.  ************************************************************************/
  440. /* Each index references a group of bytes on the page. */
  441. #define B_KEYDATA 1 /* Key/data item. */
  442. #define B_DUPLICATE 2 /* Duplicate key/data item. */
  443. #define B_OVERFLOW 3 /* Overflow key/data item. */
  445. /*
  446.  * We have to store a deleted entry flag in the page.   The reason is complex,
  447.  * but the simple version is that we can't delete on-page items referenced by
  448.  * a cursor -- the return order of subsequent insertions might be wrong.  The
  449.  * delete flag is an overload of the top bit of the type byte.
  450.  */
  451. #define B_DELETE (0x80)
  452. #define B_DCLR(t) (t) &= ~B_DELETE
  453. #define B_DSET(t) (t) |= B_DELETE
  454. #define B_DISSET(t) ((t) & B_DELETE)
  456. #define B_TYPE(t) ((t) & ~B_DELETE)
  457. #define B_TSET(t, type, deleted) {
  458. (t) = (type);
  459. if (deleted)
  460. B_DSET(t);
  461. }
  463. /*
  464.  * The first type is B_KEYDATA, represented by the BKEYDATA structure:
  465.  */
  466. typedef struct _bkeydata {
  467. db_indx_t len; /* 00-01: Key/data item length. */
  468. u_int8_t  type; /*    02: Page type AND DELETE FLAG. */
  469. u_int8_t  data[1]; /* Variable length key/data item. */
  470. } BKEYDATA;
  472. /* Get a BKEYDATA item for a specific index. */
  473. #define GET_BKEYDATA(pg, indx)
  474. ((BKEYDATA *)P_ENTRY(pg, indx))
  476. /*
  477.  * Page space required to add a new BKEYDATA item to the page, with and
  478.  * without the index value.
  479.  */
  480. #define BKEYDATA_SIZE(len)
  481. ALIGN((len) + SSZA(BKEYDATA, data), sizeof(u_int32_t))
  482. #define BKEYDATA_PSIZE(len)
  483. (BKEYDATA_SIZE(len) + sizeof(db_indx_t))
  485. /*
  486.  * The second and third types are B_DUPLICATE and B_OVERFLOW, represented
  487.  * by the BOVERFLOW structure.
  488.  */
  489. typedef struct _boverflow {
  490. db_indx_t unused1; /* 00-01: Padding, unused. */
  491. u_int8_t  type; /*    02: Page type AND DELETE FLAG. */
  492. u_int8_t  unused2; /*    03: Padding, unused. */
  493. db_pgno_t pgno; /* 04-07: Next page number. */
  494. u_int32_t tlen; /* 08-11: Total length of item. */
  495. } BOVERFLOW;
  497. /* Get a BOVERFLOW item for a specific index. */
  498. #define GET_BOVERFLOW(pg, indx)
  499. ((BOVERFLOW *)P_ENTRY(pg, indx))
  501. /*
  502.  * Page space required to add a new BOVERFLOW item to the page, with and
  503.  * without the index value.
  504.  */
  505. #define BOVERFLOW_SIZE
  506. ALIGN(sizeof(BOVERFLOW), sizeof(u_int32_t))
  507. #define BOVERFLOW_PSIZE
  508. (BOVERFLOW_SIZE + sizeof(db_indx_t))
  510. /*
  511.  * Btree leaf and hash page layouts group indices in sets of two, one for the
  512.  * key and one for the data.  Everything else does it in sets of one to save
  513.  * space.  Use the following macros so that it's real obvious what's going on.
  514.  */
  515. #define O_INDX 1
  516. #define P_INDX 2
  518. /************************************************************************
  519.  BTREE INTERNAL PAGE LAYOUT
  520.  ************************************************************************/
  522. /*
  523.  * Btree internal entry.
  524.  */
  525. typedef struct _binternal {
  526. db_indx_t  len; /* 00-01: Key/data item length. */
  527. u_int8_t   type; /*    02: Page type AND DELETE FLAG. */
  528. u_int8_t   unused; /*    03: Padding, unused. */
  529. db_pgno_t  pgno; /* 04-07: Page number of referenced page. */
  530. db_recno_t nrecs; /* 08-11: Subtree record count. */
  531. u_int8_t   data[1]; /* Variable length key item. */
  532. } BINTERNAL;
  534. /* Get a BINTERNAL item for a specific index. */
  535. #define GET_BINTERNAL(pg, indx)
  536. ((BINTERNAL *)P_ENTRY(pg, indx))
  538. /*
  539.  * Page space required to add a new BINTERNAL item to the page, with and
  540.  * without the index value.
  541.  */
  542. #define BINTERNAL_SIZE(len)
  543. ALIGN((len) + SSZA(BINTERNAL, data), sizeof(u_int32_t))
  544. #define BINTERNAL_PSIZE(len)
  545. (BINTERNAL_SIZE(len) + sizeof(db_indx_t))
  547. /************************************************************************
  548.  RECNO INTERNAL PAGE LAYOUT
  549.  ************************************************************************/
  551. /*
  552.  * The recno internal entry.
  553.  */
  554. typedef struct _rinternal {
  555. db_pgno_t  pgno; /* 00-03: Page number of referenced page. */
  556. db_recno_t nrecs; /* 04-07: Subtree record count. */
  557. } RINTERNAL;
  559. /* Get a RINTERNAL item for a specific index. */
  560. #define GET_RINTERNAL(pg, indx)
  561. ((RINTERNAL *)P_ENTRY(pg, indx))
  563. /*
  564.  * Page space required to add a new RINTERNAL item to the page, with and
  565.  * without the index value.
  566.  */
  567. #define RINTERNAL_SIZE
  568. ALIGN(sizeof(RINTERNAL), sizeof(u_int32_t))
  569. #define RINTERNAL_PSIZE
  570. (RINTERNAL_SIZE + sizeof(db_indx_t))
  572. #if defined(__cplusplus)
  573. }
  574. #endif
  576. #endif /* _DB_PAGE_H_ */