bt_method.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: bt_method.c,v 11.29 2002/04/21 13:17:04 margo Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #endif
  14. #include "db_int.h"
  15. #include "dbinc/db_page.h"
  16. #include "dbinc/btree.h"
  17. #include "dbinc/qam.h"
  18. static int __bam_set_bt_compare
  19.        __P((DB *, int (*)(DB *, const DBT *, const DBT *)));
  20. static int __bam_set_bt_maxkey __P((DB *, u_int32_t));
  21. static int __bam_set_bt_minkey __P((DB *, u_int32_t));
  22. static int __bam_set_bt_prefix
  23.        __P((DB *, size_t(*)(DB *, const DBT *, const DBT *)));
  24. static int __ram_set_re_delim __P((DB *, int));
  25. static int __ram_set_re_len __P((DB *, u_int32_t));
  26. static int __ram_set_re_pad __P((DB *, int));
  27. static int __ram_set_re_source __P((DB *, const char *));
  28. /*
  29.  * __bam_db_create --
  30.  * Btree specific initialization of the DB structure.
  31.  *
  32.  * PUBLIC: int __bam_db_create __P((DB *));
  33.  */
  34. int
  35. __bam_db_create(dbp)
  36. DB *dbp;
  37. {
  38. BTREE *t;
  39. int ret;
  40. /* Allocate and initialize the private btree structure. */
  41. if ((ret = __os_calloc(dbp->dbenv, 1, sizeof(BTREE), &t)) != 0)
  42. return (ret);
  43. dbp->bt_internal = t;
  44. t->bt_minkey = DEFMINKEYPAGE; /* Btree */
  45. t->bt_compare = __bam_defcmp;
  46. t->bt_prefix = __bam_defpfx;
  47. dbp->set_bt_compare = __bam_set_bt_compare;
  48. dbp->set_bt_maxkey = __bam_set_bt_maxkey;
  49. dbp->set_bt_minkey = __bam_set_bt_minkey;
  50. dbp->set_bt_prefix = __bam_set_bt_prefix;
  51. t->re_pad = ' '; /* Recno */
  52. t->re_delim = 'n';
  53. t->re_eof = 1;
  54. dbp->set_re_delim = __ram_set_re_delim;
  55. dbp->set_re_len = __ram_set_re_len;
  56. dbp->set_re_pad = __ram_set_re_pad;
  57. dbp->set_re_source = __ram_set_re_source;
  58. return (0);
  59. }
  60. /*
  61.  * __bam_db_close --
  62.  * Btree specific discard of the DB structure.
  63.  *
  64.  * PUBLIC: int __bam_db_close __P((DB *));
  65.  */
  66. int
  67. __bam_db_close(dbp)
  68. DB *dbp;
  69. {
  70. BTREE *t;
  71. if ((t = dbp->bt_internal) == NULL)
  72. return (0);
  73. /* Recno */
  74. /* Close any backing source file descriptor. */
  75. if (t->re_fp != NULL)
  76. (void)fclose(t->re_fp);
  77. /* Free any backing source file name. */
  78. if (t->re_source != NULL)
  79. __os_free(dbp->dbenv, t->re_source);
  80. __os_free(dbp->dbenv, t);
  81. dbp->bt_internal = NULL;
  82. return (0);
  83. }
  84. /*
  85.  * __bam_set_flags --
  86.  * Set Btree specific flags.
  87.  *
  88.  * PUBLIC: int __bam_set_flags __P((DB *, u_int32_t *flagsp));
  89.  */
  90. int
  91. __bam_set_flags(dbp, flagsp)
  92. DB *dbp;
  93. u_int32_t *flagsp;
  94. {
  95. u_int32_t flags;
  96. flags = *flagsp;
  97. if (LF_ISSET(DB_DUP | DB_DUPSORT | DB_RECNUM | DB_REVSPLITOFF)) {
  98. DB_ILLEGAL_AFTER_OPEN(dbp, "DB->set_flags");
  99. /*
  100.  * The DB_DUP and DB_DUPSORT flags are shared by the Hash
  101.  * and Btree access methods.
  102.  */
  103. if (LF_ISSET(DB_DUP | DB_DUPSORT))
  104. DB_ILLEGAL_METHOD(dbp, DB_OK_BTREE | DB_OK_HASH);
  105. if (LF_ISSET(DB_RECNUM | DB_REVSPLITOFF))
  106. DB_ILLEGAL_METHOD(dbp, DB_OK_BTREE);
  107. if (LF_ISSET(DB_DUP | DB_DUPSORT)) {
  108. /* DB_DUP/DB_DUPSORT is incompatible with DB_RECNUM. */
  109. if (F_ISSET(dbp, DB_AM_RECNUM))
  110. goto incompat;
  111. if (LF_ISSET(DB_DUPSORT)) {
  112. if (dbp->dup_compare == NULL)
  113. dbp->dup_compare = __bam_defcmp;
  114. F_SET(dbp, DB_AM_DUPSORT);
  115. }
  116. F_SET(dbp, DB_AM_DUP);
  117. LF_CLR(DB_DUP | DB_DUPSORT);
  118. }
  119. if (LF_ISSET(DB_RECNUM)) {
  120. /* DB_RECNUM is incompatible with DB_DUP/DB_DUPSORT. */
  121. if (F_ISSET(dbp, DB_AM_DUP))
  122. goto incompat;
  123. F_SET(dbp, DB_AM_RECNUM);
  124. LF_CLR(DB_RECNUM);
  125. }
  126. if (LF_ISSET(DB_REVSPLITOFF)) {
  127. F_SET(dbp, DB_AM_REVSPLITOFF);
  128. LF_CLR(DB_REVSPLITOFF);
  129. }
  130. *flagsp = flags;
  131. }
  132. return (0);
  133. incompat:
  134. return (__db_ferr(dbp->dbenv, "DB->set_flags", 1));
  135. }
  136. /*
  137.  * __bam_set_bt_compare --
  138.  * Set the comparison function.
  139.  */
  140. static int
  141. __bam_set_bt_compare(dbp, func)
  142. DB *dbp;
  143. int (*func) __P((DB *, const DBT *, const DBT *));
  144. {
  145. BTREE *t;
  146. DB_ILLEGAL_AFTER_OPEN(dbp, "set_bt_compare");
  147. DB_ILLEGAL_METHOD(dbp, DB_OK_BTREE);
  148. t = dbp->bt_internal;
  149. /*
  150.  * Can't default the prefix routine if the user supplies a comparison
  151.  * routine; shortening the keys can break their comparison algorithm.
  152.  */
  153. t->bt_compare = func;
  154. if (t->bt_prefix == __bam_defpfx)
  155. t->bt_prefix = NULL;
  156. return (0);
  157. }
  158. /*
  159.  * __bam_set_bt_maxkey --
  160.  * Set the maximum keys per page.
  161.  */
  162. static int
  163. __bam_set_bt_maxkey(dbp, bt_maxkey)
  164. DB *dbp;
  165. u_int32_t bt_maxkey;
  166. {
  167. BTREE *t;
  168. DB_ILLEGAL_AFTER_OPEN(dbp, "set_bt_maxkey");
  169. DB_ILLEGAL_METHOD(dbp, DB_OK_BTREE);
  170. t = dbp->bt_internal;
  171. if (bt_maxkey < 1) {
  172. __db_err(dbp->dbenv, "minimum bt_maxkey value is 1");
  173. return (EINVAL);
  174. }
  175. t->bt_maxkey = bt_maxkey;
  176. return (0);
  177. }
  178. /*
  179.  * __bam_set_bt_minkey --
  180.  * Set the minimum keys per page.
  181.  */
  182. static int
  183. __bam_set_bt_minkey(dbp, bt_minkey)
  184. DB *dbp;
  185. u_int32_t bt_minkey;
  186. {
  187. BTREE *t;
  188. DB_ILLEGAL_AFTER_OPEN(dbp, "set_bt_minkey");
  189. DB_ILLEGAL_METHOD(dbp, DB_OK_BTREE);
  190. t = dbp->bt_internal;
  191. if (bt_minkey < 2) {
  192. __db_err(dbp->dbenv, "minimum bt_minkey value is 2");
  193. return (EINVAL);
  194. }
  195. t->bt_minkey = bt_minkey;
  196. return (0);
  197. }
  198. /*
  199.  * __bam_set_bt_prefix --
  200.  * Set the prefix function.
  201.  */
  202. static int
  203. __bam_set_bt_prefix(dbp, func)
  204. DB *dbp;
  205. size_t (*func) __P((DB *, const DBT *, const DBT *));
  206. {
  207. BTREE *t;
  208. DB_ILLEGAL_AFTER_OPEN(dbp, "set_bt_prefix");
  209. DB_ILLEGAL_METHOD(dbp, DB_OK_BTREE);
  210. t = dbp->bt_internal;
  211. t->bt_prefix = func;
  212. return (0);
  213. }
  214. /*
  215.  * __ram_set_flags --
  216.  * Set Recno specific flags.
  217.  *
  218.  * PUBLIC: int __ram_set_flags __P((DB *, u_int32_t *flagsp));
  219.  */
  220. int
  221. __ram_set_flags(dbp, flagsp)
  222. DB *dbp;
  223. u_int32_t *flagsp;
  224. {
  225. u_int32_t flags;
  226. flags = *flagsp;
  227. if (LF_ISSET(DB_RENUMBER | DB_SNAPSHOT)) {
  228. DB_ILLEGAL_AFTER_OPEN(dbp, "DB->set_flags");
  229. DB_ILLEGAL_METHOD(dbp, DB_OK_RECNO);
  230. if (LF_ISSET(DB_RENUMBER)) {
  231. F_SET(dbp, DB_AM_RENUMBER);
  232. LF_CLR(DB_RENUMBER);
  233. }
  234. if (LF_ISSET(DB_SNAPSHOT)) {
  235. F_SET(dbp, DB_AM_SNAPSHOT);
  236. LF_CLR(DB_SNAPSHOT);
  237. }
  238. *flagsp = flags;
  239. }
  240. return (0);
  241. }
  242. /*
  243.  * __ram_set_re_delim --
  244.  * Set the variable-length input record delimiter.
  245.  */
  246. static int
  247. __ram_set_re_delim(dbp, re_delim)
  248. DB *dbp;
  249. int re_delim;
  250. {
  251. BTREE *t;
  252. DB_ILLEGAL_AFTER_OPEN(dbp, "set_re_delim");
  253. DB_ILLEGAL_METHOD(dbp, DB_OK_RECNO);
  254. t = dbp->bt_internal;
  255. t->re_delim = re_delim;
  256. F_SET(dbp, DB_AM_DELIMITER);
  257. return (0);
  258. }
  259. /*
  260.  * __ram_set_re_len --
  261.  * Set the variable-length input record length.
  262.  */
  263. static int
  264. __ram_set_re_len(dbp, re_len)
  265. DB *dbp;
  266. u_int32_t re_len;
  267. {
  268. BTREE *t;
  269. QUEUE *q;
  270. DB_ILLEGAL_AFTER_OPEN(dbp, "set_re_len");
  271. DB_ILLEGAL_METHOD(dbp, DB_OK_QUEUE | DB_OK_RECNO);
  272. t = dbp->bt_internal;
  273. t->re_len = re_len;
  274. q = dbp->q_internal;
  275. q->re_len = re_len;
  276. F_SET(dbp, DB_AM_FIXEDLEN);
  277. return (0);
  278. }
  279. /*
  280.  * __ram_set_re_pad --
  281.  * Set the fixed-length record pad character.
  282.  */
  283. static int
  284. __ram_set_re_pad(dbp, re_pad)
  285. DB *dbp;
  286. int re_pad;
  287. {
  288. BTREE *t;
  289. QUEUE *q;
  290. DB_ILLEGAL_AFTER_OPEN(dbp, "set_re_pad");
  291. DB_ILLEGAL_METHOD(dbp, DB_OK_QUEUE | DB_OK_RECNO);
  292. t = dbp->bt_internal;
  293. t->re_pad = re_pad;
  294. q = dbp->q_internal;
  295. q->re_pad = re_pad;
  296. F_SET(dbp, DB_AM_PAD);
  297. return (0);
  298. }
  299. /*
  300.  * __ram_set_re_source --
  301.  * Set the backing source file name.
  302.  */
  303. static int
  304. __ram_set_re_source(dbp, re_source)
  305. DB *dbp;
  306. const char *re_source;
  307. {
  308. BTREE *t;
  309. DB_ILLEGAL_AFTER_OPEN(dbp, "set_re_source");
  310. DB_ILLEGAL_METHOD(dbp, DB_OK_RECNO);
  311. t = dbp->bt_internal;
  312. return (__os_strdup(dbp->dbenv, re_source, &t->re_source));
  313. }