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

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

MySQL数据库

开发平台：

Visual C++

db185.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 copyright[] =
  12.     "Copyright (c) 1996-2000nSleepycat Software Inc.  All rights reserved.n";
  13. static const char revid[] =
  14.     "$Id: db185.c,v 11.15 2001/01/23 21:27:03 bostic Exp $";
  15. #endif
  17. #ifndef NO_SYSTEM_INCLUDES
  18. #include <sys/types.h>
  20. #include <fcntl.h>
  21. #include <string.h>
  22. #include <unistd.h>
  23. #endif
  25. #include "db_int.h"
  26. #include "db185_int.h"
  28. static int db185_close __P((DB185 *));
  29. static int db185_compare __P((DB *, const DBT *, const DBT *));
  30. static int db185_del __P((const DB185 *, const DBT185 *, u_int));
  31. static int db185_fd __P((const DB185 *));
  32. static int db185_get __P((const DB185 *, const DBT185 *, DBT185 *, u_int));
  33. static u_int32_t
  34. db185_hash __P((DB *, const void *, u_int32_t));
  35. static void db185_openstderr __P((DB_FH *));
  36. static size_t db185_prefix __P((DB *, const DBT *, const DBT *));
  37. static int db185_put __P((const DB185 *, DBT185 *, const DBT185 *, u_int));
  38. static int db185_seq __P((const DB185 *, DBT185 *, DBT185 *, u_int));
  39. static int db185_sync __P((const DB185 *, u_int));
  41. DB185 *
  42. __db185_open(file, oflags, mode, type, openinfo)
  43. const char *file;
  44. int oflags, mode;
  45. DBTYPE type;
  46. const void *openinfo;
  47. {
  48. const BTREEINFO *bi;
  49. const HASHINFO *hi;
  50. const RECNOINFO *ri;
  51. DB *dbp;
  52. DB185 *db185p;
  53. DB_FH fh;
  54. size_t nw;
  55. int ret;
  57. dbp = NULL;
  58. db185p = NULL;
  60. if ((ret = db_create(&dbp, NULL, 0)) != 0)
  61. goto err;
  63. if ((ret = __os_calloc(NULL, 1, sizeof(DB185), &db185p)) != 0)
  64. goto err;
  66. /*
  67.  * !!!
  68.  * The DBTYPE enum wasn't initialized in DB 185, so it's off-by-one
  69.  * from DB 2.0.
  70.  */
  71. switch (type) {
  72. case 0: /* DB_BTREE */
  73. type = DB_BTREE;
  74. if ((bi = openinfo) != NULL) {
  75. if (bi->flags & ~R_DUP)
  76. goto einval;
  77. if (bi->flags & R_DUP)
  78. (void)dbp->set_flags(dbp, DB_DUP);
  79. if (bi->cachesize != 0)
  80. (void)dbp->set_cachesize
  81.     (dbp, 0, bi->cachesize, 0);
  82. if (bi->minkeypage != 0)
  83. (void)dbp->set_bt_minkey(dbp, bi->minkeypage);
  84. if (bi->psize != 0)
  85. (void)dbp->set_pagesize(dbp, bi->psize);
  86. /*
  87.  * !!!
  88.  * Comparisons and prefix calls work because the DBT
  89.  * structures in 1.85 and 2.0 have the same initial
  90.  * fields.
  91.  */
  92. if (bi->prefix != NULL) {
  93. db185p->prefix = bi->prefix;
  94. dbp->set_bt_prefix(dbp, db185_prefix);
  95. }
  96. if (bi->compare != NULL) {
  97. db185p->compare = bi->compare;
  98. dbp->set_bt_compare(dbp, db185_compare);
  99. }
  100. if (bi->lorder != 0)
  101. dbp->set_lorder(dbp, bi->lorder);
  102. }
  103. break;
  104. case 1: /* DB_HASH */
  105. type = DB_HASH;
  106. if ((hi = openinfo) != NULL) {
  107. if (hi->bsize != 0)
  108. (void)dbp->set_pagesize(dbp, hi->bsize);
  109. if (hi->ffactor != 0)
  110. (void)dbp->set_h_ffactor(dbp, hi->ffactor);
  111. if (hi->nelem != 0)
  112. (void)dbp->set_h_nelem(dbp, hi->nelem);
  113. if (hi->cachesize != 0)
  114. (void)dbp->set_cachesize
  115.     (dbp, 0, hi->cachesize, 0);
  116. if (hi->hash != NULL) {
  117. db185p->hash = hi->hash;
  118. (void)dbp->set_h_hash(dbp, db185_hash);
  119. }
  120. if (hi->lorder != 0)
  121. dbp->set_lorder(dbp, hi->lorder);
  122. }
  124. break;
  125. case 2: /* DB_RECNO */
  126. type = DB_RECNO;
  128. /* DB 1.85 did renumbering by default. */
  129. (void)dbp->set_flags(dbp, DB_RENUMBER);
  131. /*
  132.  * !!!
  133.  * The file name given to DB 1.85 recno is the name of the DB
  134.  * 2.0 backing file.  If the file doesn't exist, create it if
  135.  * the user has the O_CREAT flag set, DB 1.85 did it for you,
  136.  * and DB 2.0 doesn't.
  137.  *
  138.  * !!!
  139.  * Setting the file name to NULL specifies that we're creating
  140.  * a temporary backing file, in DB 2.X.  If we're opening the
  141.  * DB file read-only, change the flags to read-write, because
  142.  * temporary backing files cannot be opened read-only, and DB
  143.  * 2.X will return an error.  We are cheating here -- if the
  144.  * application does a put on the database, it will succeed --
  145.  * although that would be a stupid thing for the application
  146.  * to do.
  147.  *
  148.  * !!!
  149.  * Note, the file name in DB 1.85 was a const -- we don't do
  150.  * that in DB 2.0, so do that cast.
  151.  */
  152. if (file != NULL) {
  153. if (oflags & O_CREAT && __os_exists(file, NULL) != 0)
  154. if (__os_openhandle(NULL, file,
  155.     oflags, mode, &fh) == 0)
  156. (void)__os_closehandle(&fh);
  157. (void)dbp->set_re_source(dbp, file);
  159. if (O_RDONLY)
  160. oflags &= ~O_RDONLY;
  161. oflags |= O_RDWR;
  162. file = NULL;
  163. }
  165. if ((ri = openinfo) != NULL) {
  166. /*
  167.  * !!!
  168.  * We can't support the bfname field.
  169.  */
  170. #define BFMSG "DB: DB 1.85's recno bfname field is not supported.n"
  171. if (ri->bfname != NULL) {
  172. db185_openstderr(&fh);
  173. (void)__os_write(NULL, &fh,
  174.     BFMSG, sizeof(BFMSG) - 1, &nw);
  175. goto einval;
  176. }
  178. if (ri->flags & ~(R_FIXEDLEN | R_NOKEY | R_SNAPSHOT))
  179. goto einval;
  180. if (ri->flags & R_FIXEDLEN) {
  181. if (ri->bval != 0)
  182. (void)dbp->set_re_pad(dbp, ri->bval);
  183. if (ri->reclen != 0)
  184. (void)dbp->set_re_len(dbp, ri->reclen);
  185. } else
  186. if (ri->bval != 0)
  187. (void)dbp->set_re_delim(dbp, ri->bval);
  189. /*
  190.  * !!!
  191.  * We ignore the R_NOKEY flag, but that's okay, it was
  192.  * only an optimization that was never implemented.
  193.  */
  194. if (ri->flags & R_SNAPSHOT)
  195. (void)dbp->set_flags(dbp, DB_SNAPSHOT);
  197. if (ri->cachesize != 0)
  198. (void)dbp->set_cachesize
  199.     (dbp, 0, ri->cachesize, 0);
  200. if (ri->psize != 0)
  201. (void)dbp->set_pagesize(dbp, ri->psize);
  202. if (ri->lorder != 0)
  203. dbp->set_lorder(dbp, ri->lorder);
  204. }
  205. break;
  206. default:
  207. goto einval;
  208. }
  210. db185p->close = db185_close;
  211. db185p->del = db185_del;
  212. db185p->fd = db185_fd;
  213. db185p->get = db185_get;
  214. db185p->put = db185_put;
  215. db185p->seq = db185_seq;
  216. db185p->sync = db185_sync;
  218. /*
  219.  * Store a reference so we can indirect from the DB 1.85 structure
  220.  * to the underlying DB structure, and vice-versa.  This has to be
  221.  * done BEFORE the DB::open method call because the hash callback
  222.  * is exercised as part of hash database initialiation.
  223.  *
  224.  * XXX
  225.  * Overload the cj_internal field for this purpose.
  226.  */
  227. db185p->dbp = dbp;
  228. dbp->cj_internal = db185p;
  230. /* Open the database. */
  231. if ((ret = dbp->open(dbp,
  232.     file, NULL, type, __db_oflags(oflags), mode)) != 0)
  233. goto err;
  235. /* Create the cursor used for sequential ops. */
  236. if ((ret = dbp->cursor(dbp, NULL, &((DB185 *)db185p)->dbc, 0)) != 0)
  237. goto err;
  239. return (db185p);
  241. einval: ret = EINVAL;
  243. err: if (db185p != NULL)
  244. __os_free(db185p, sizeof(DB185));
  245. if (dbp != NULL)
  246. (void)dbp->close(dbp, 0);
  248. __os_set_errno(ret);
  249. return (NULL);
  250. }
  252. static int
  253. db185_close(db185p)
  254. DB185 *db185p;
  255. {
  256. DB *dbp;
  257. int ret;
  259. dbp = db185p->dbp;
  261. ret = dbp->close(dbp, 0);
  263. __os_free(db185p, sizeof(DB185));
  265. if (ret == 0)
  266. return (0);
  268. __os_set_errno(ret);
  269. return (-1);
  270. }
  272. static int
  273. db185_del(db185p, key185, flags)
  274. const DB185 *db185p;
  275. const DBT185 *key185;
  276. u_int flags;
  277. {
  278. DB *dbp;
  279. DBT key;
  280. int ret;
  282. dbp = db185p->dbp;
  284. memset(&key, 0, sizeof(key));
  285. key.data = key185->data;
  286. key.size = key185->size;
  288. if (flags & ~R_CURSOR)
  289. goto einval;
  290. if (flags & R_CURSOR)
  291. ret = db185p->dbc->c_del(db185p->dbc, 0);
  292. else
  293. ret = dbp->del(dbp, NULL, &key, 0);
  295. switch (ret) {
  296. case 0:
  297. return (0);
  298. case DB_NOTFOUND:
  299. return (1);
  300. }
  302. __os_set_errno(ret);
  303. return (-1);
  305. einval: __os_set_errno(EINVAL);
  306. return (-1);
  307. }
  309. static int
  310. db185_fd(db185p)
  311. const DB185 *db185p;
  312. {
  313. DB *dbp;
  314. int fd, ret;
  316. dbp = db185p->dbp;
  318. if ((ret = dbp->fd(dbp, &fd)) == 0)
  319. return (fd);
  321. __os_set_errno(ret);
  322. return (-1);
  323. }
  325. static int
  326. db185_get(db185p, key185, data185, flags)
  327. const DB185 *db185p;
  328. const DBT185 *key185;
  329. DBT185 *data185;
  330. u_int flags;
  331. {
  332. DB *dbp;
  333. DBT key, data;
  334. int ret;
  336. dbp = db185p->dbp;
  338. memset(&key, 0, sizeof(key));
  339. key.data = key185->data;
  340. key.size = key185->size;
  341. memset(&data, 0, sizeof(data));
  342. data.data = data185->data;
  343. data.size = data185->size;
  345. if (flags)
  346. goto einval;
  348. switch (ret = dbp->get(dbp, NULL, &key, &data, 0)) {
  349. case 0:
  350. data185->data = data.data;
  351. data185->size = data.size;
  352. return (0);
  353. case DB_NOTFOUND:
  354. return (1);
  355. }
  357. __os_set_errno(ret);
  358. return (-1);
  360. einval: __os_set_errno(EINVAL);
  361. return (-1);
  362. }
  364. static int
  365. db185_put(db185p, key185, data185, flags)
  366. const DB185 *db185p;
  367. DBT185 *key185;
  368. const DBT185 *data185;
  369. u_int flags;
  370. {
  371. DB *dbp;
  372. DBC *dbcp_put;
  373. DBT key, data;
  374. int ret;
  376. dbp = db185p->dbp;
  378. memset(&key, 0, sizeof(key));
  379. key.data = key185->data;
  380. key.size = key185->size;
  381. memset(&data, 0, sizeof(data));
  382. data.data = data185->data;
  383. data.size = data185->size;
  385. switch (flags) {
  386. case 0:
  387. ret = dbp->put(dbp, NULL, &key, &data, 0);
  388. break;
  389. case R_CURSOR:
  390. ret = db185p->dbc->c_put(db185p->dbc, &key, &data, DB_CURRENT);
  391. break;
  392. case R_IAFTER:
  393. case R_IBEFORE:
  394. if (dbp->type != DB_RECNO)
  395. goto einval;
  397. if ((ret = dbp->cursor(dbp, NULL, &dbcp_put, 0)) != 0) {
  398. __os_set_errno(ret);
  399. return (-1);
  400. }
  401. if ((ret =
  402.     dbcp_put->c_get(dbcp_put, &key, &data, DB_SET)) != 0) {
  403. (void)dbcp_put->c_close(dbcp_put);
  404. __os_set_errno(ret);
  405. return (-1);
  406. }
  407. memset(&data, 0, sizeof(data));
  408. data.data = data185->data;
  409. data.size = data185->size;
  410. ret = dbcp_put->c_put(dbcp_put,
  411.     &key, &data, flags == R_IAFTER ? DB_AFTER : DB_BEFORE);
  412. (void)dbcp_put->c_close(dbcp_put);
  413. __os_set_errno(ret);
  414. break;
  415. case R_NOOVERWRITE:
  416. ret = dbp->put(dbp, NULL, &key, &data, DB_NOOVERWRITE);
  417. break;
  418. case R_SETCURSOR:
  419. if (dbp->type != DB_BTREE && dbp->type != DB_RECNO)
  420. goto einval;
  422. if ((ret = dbp->put(dbp, NULL, &key, &data, 0)) != 0)
  423. break;
  424. ret =
  425.     db185p->dbc->c_get(db185p->dbc, &key, &data, DB_SET_RANGE);
  426. break;
  427. default:
  428. goto einval;
  429. }
  431. switch (ret) {
  432. case 0:
  433. key185->data = key.data;
  434. key185->size = key.size;
  435. return (0);
  436. case DB_KEYEXIST:
  437. return (1);
  438. }
  439. __os_set_errno(ret);
  440. return (-1);
  442. einval: __os_set_errno(EINVAL);
  443. return (-1);
  444. }
  446. static int
  447. db185_seq(db185p, key185, data185, flags)
  448. const DB185 *db185p;
  449. DBT185 *key185, *data185;
  450. u_int flags;
  451. {
  452. DB *dbp;
  453. DBT key, data;
  454. int ret;
  456. dbp = db185p->dbp;
  458. memset(&key, 0, sizeof(key));
  459. key.data = key185->data;
  460. key.size = key185->size;
  461. memset(&data, 0, sizeof(data));
  462. data.data = data185->data;
  463. data.size = data185->size;
  465. switch (flags) {
  466. case R_CURSOR:
  467. flags = DB_SET_RANGE;
  468. break;
  469. case R_FIRST:
  470. flags = DB_FIRST;
  471. break;
  472. case R_LAST:
  473. if (dbp->type != DB_BTREE && dbp->type != DB_RECNO)
  474. goto einval;
  475. flags = DB_LAST;
  476. break;
  477. case R_NEXT:
  478. flags = DB_NEXT;
  479. break;
  480. case R_PREV:
  481. if (dbp->type != DB_BTREE && dbp->type != DB_RECNO)
  482. goto einval;
  483. flags = DB_PREV;
  484. break;
  485. default:
  486. goto einval;
  487. }
  488. switch (ret = db185p->dbc->c_get(db185p->dbc, &key, &data, flags)) {
  489. case 0:
  490. key185->data = key.data;
  491. key185->size = key.size;
  492. data185->data = data.data;
  493. data185->size = data.size;
  494. return (0);
  495. case DB_NOTFOUND:
  496. return (1);
  497. }
  499. __os_set_errno(ret);
  500. return (-1);
  502. einval: __os_set_errno(EINVAL);
  503. return (-1);
  504. }
  506. static int
  507. db185_sync(db185p, flags)
  508. const DB185 *db185p;
  509. u_int flags;
  510. {
  511. DB *dbp;
  512. DB_FH fh;
  513. size_t nw;
  514. int ret;
  516. dbp = db185p->dbp;
  518. switch (flags) {
  519. case 0:
  520. break;
  521. case R_RECNOSYNC:
  522. /*
  523.  * !!!
  524.  * We can't support the R_RECNOSYNC flag.
  525.  */
  526. #define RSMSG "DB: DB 1.85's R_RECNOSYNC sync flag is not supported.n"
  527. db185_openstderr(&fh);
  528. (void)__os_write(NULL, &fh, RSMSG, sizeof(RSMSG) - 1, &nw);
  529. goto einval;
  530. default:
  531. goto einval;
  532. }
  534. if ((ret = dbp->sync(dbp, 0)) == 0)
  535. return (0);
  537. __os_set_errno(ret);
  538. return (-1);
  540. einval: __os_set_errno(EINVAL);
  541. return (-1);
  542. }
  544. static void
  545. db185_openstderr(fhp)
  546. DB_FH *fhp;
  547. {
  548. /* Dummy up the results of an __os_openhandle() on stderr. */
  549. memset(fhp, 0, sizeof(*fhp));
  550. F_SET(fhp, DB_FH_VALID);
  552. #ifndef STDERR_FILENO
  553. #define STDERR_FILENO 2
  554. #endif
  555. fhp->fd = STDERR_FILENO;
  556. }
  558. /*
  559.  * db185_compare --
  560.  * Cutout routine to call the user's Btree comparison function.
  561.  */
  562. static int
  563. db185_compare(dbp, a, b)
  564. DB *dbp;
  565. const DBT *a, *b;
  566. {
  567. return (((DB185 *)dbp->cj_internal)->compare(a, b));
  568. }
  570. /*
  571.  * db185_prefix --
  572.  * Cutout routine to call the user's Btree prefix function.
  573.  */
  574. static size_t
  575. db185_prefix(dbp, a, b)
  576. DB *dbp;
  577. const DBT *a, *b;
  578. {
  579. return (((DB185 *)dbp->cj_internal)->prefix(a, b));
  580. }
  582. /*
  583.  * db185_hash --
  584.  * Cutout routine to call the user's hash function.
  585.  */
  586. static u_int32_t
  587. db185_hash(dbp, key, len)
  588. DB *dbp;
  589. const void *key;
  590. u_int32_t len;
  591. {
  592. return (((DB185 *)dbp->cj_internal)->hash(key, (size_t)len));
  593. }