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

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

MySQL数据库

开发平台：

Visual C++

qam.c：源码内容
  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1999, 2000
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  8. #include "db_config.h"
  10. #ifndef lint
  11. static const char revid[] = "$Id: qam.c,v 11.72 2001/01/16 20:10:55 ubell 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 "db_page.h"
  22. #include "db_shash.h"
  23. #include "db_am.h"
  24. #include "mp.h"
  25. #include "lock.h"
  26. #include "log.h"
  27. #include "btree.h"
  28. #include "qam.h"
  30. static int __qam_c_close __P((DBC *, db_pgno_t, int *));
  31. static int __qam_c_del __P((DBC *));
  32. static int __qam_c_destroy __P((DBC *));
  33. static int __qam_c_get __P((DBC *, DBT *, DBT *, u_int32_t, db_pgno_t *));
  34. static int __qam_c_put __P((DBC *, DBT *, DBT *, u_int32_t, db_pgno_t *));
  35. static int __qam_getno __P((DB *, const DBT *, db_recno_t *));
  37. /*
  38.  * __qam_position --
  39.  * Position a queued access method cursor at a record.  This returns
  40.  * the page locked.  *exactp will be set if the record is valid.
  41.  * PUBLIC: int __qam_position
  42.  * PUBLIC:       __P((DBC *, db_recno_t *, qam_position_mode, int *));
  43.  */
  44. int
  45. __qam_position(dbc, recnop, mode, exactp)
  46. DBC *dbc; /* open cursor */
  47. db_recno_t *recnop; /* pointer to recno to find */
  48. qam_position_mode mode;/* locking: read or write */
  49. int *exactp; /* indicate if it was found */
  50. {
  51. QUEUE_CURSOR *cp;
  52. DB *dbp;
  53. QAMDATA  *qp;
  54. db_pgno_t pg;
  55. int ret;
  57. dbp = dbc->dbp;
  58. cp = (QUEUE_CURSOR *)dbc->internal;
  60. /* Fetch the page for this recno. */
  61. pg = QAM_RECNO_PAGE(dbp, *recnop);
  63. if ((ret = __db_lget(dbc, 0, pg, mode == QAM_READ ?
  64.      DB_LOCK_READ : DB_LOCK_WRITE, 0, &cp->lock)) != 0)
  65. return (ret);
  66. cp->page = NULL;
  67. *exactp = 0;
  68. if ((ret = __qam_fget(dbp, &pg,
  69.     mode == QAM_WRITE ? DB_MPOOL_CREATE : 0,
  70.     &cp->page)) != 0) {
  71. /* We did not fetch it, we can release the lock. */
  72. (void)__LPUT(dbc, cp->lock);
  73. cp->lock.off = LOCK_INVALID;
  74. if (mode != QAM_WRITE && (ret == EINVAL || ret == ENOENT))
  75. return (0);
  76. return (ret);
  77. }
  78. cp->pgno = pg;
  79. cp->indx = QAM_RECNO_INDEX(dbp, pg, *recnop);
  81. if (PGNO(cp->page) == 0) {
  82. if (F_ISSET(dbp, DB_AM_RDONLY)) {
  83. *exactp = 0;
  84. return (0);
  85. }
  86. PGNO(cp->page) = pg;
  87. TYPE(cp->page) = P_QAMDATA;
  88. }
  90. qp = QAM_GET_RECORD(dbp, cp->page, cp->indx);
  91. *exactp = F_ISSET(qp, QAM_VALID);
  93. return (ret);
  94. }
  96. /*
  97.  * __qam_pitem --
  98.  * Put an item on a queue page.  Copy the data to the page and set the
  99.  * VALID and SET bits.  If logging and the record was previously set,
  100.  * log that data, otherwise just log the new data.
  101.  *
  102.  *   pagep must be write locked
  103.  *
  104.  * PUBLIC: int __qam_pitem
  105.  * PUBLIC:     __P((DBC *,  QPAGE *, u_int32_t, db_recno_t, DBT *));
  106.  */
  107. int
  108. __qam_pitem(dbc, pagep, indx, recno, data)
  109. DBC *dbc;
  110. QPAGE *pagep;
  111. u_int32_t indx;
  112. db_recno_t recno;
  113. DBT *data;
  114. {
  115. DB *dbp;
  116. DBT olddata, pdata, *datap;
  117. QAMDATA *qp;
  118. QUEUE *t;
  119. u_int32_t size;
  120. u_int8_t *dest, *p;
  121. int alloced, ret;
  123. alloced = ret = 0;
  125. dbp = dbc->dbp;
  126. t = (QUEUE *)dbp->q_internal;
  128. if (data->size > t->re_len)
  129. goto len_err;
  131. qp = QAM_GET_RECORD(dbp, pagep, indx);
  133. p = qp->data;
  134. size = data->size;
  135. datap = data;
  136. if (F_ISSET(data, DB_DBT_PARTIAL)) {
  137. if (data->doff + data->dlen > t->re_len) {
  138. alloced = data->dlen;
  139. goto len_err;
  140. }
  141. if (data->size != data->dlen) {
  142. len_err: __db_err(dbp->dbenv,
  143.     "Length improper for fixed length record %lu",
  144.     (u_long)(alloced ? alloced : data->size));
  145. return (EINVAL);
  146. }
  147. if (data->size == t->re_len)
  148. goto no_partial;
  150. /*
  151.  * If we are logging, then we have to build the record
  152.  * first, otherwise, we can simply drop the change
  153.  * directly on the page.  After this clause, make
  154.  * sure that datap and p are set up correctly so that
  155.  * copying datap into p does the right thing.
  156.  *
  157.  * Note, I am changing this so that if the existing
  158.  * record is not valid, we create a complete record
  159.  * to log so that both this and the recovery code is simpler.
  160.  */
  162. if (DB_LOGGING(dbc) || !F_ISSET(qp, QAM_VALID)) {
  163. datap = &pdata;
  164. memset(datap, 0, sizeof(*datap));
  166. if ((ret = __os_malloc(dbp->dbenv,
  167.     t->re_len, NULL, &datap->data)) != 0)
  168. return (ret);
  169. alloced = 1;
  170. datap->size = t->re_len;
  172. /*
  173.  * Construct the record if it's valid, otherwise set it
  174.  * all to the pad character.
  175.  */
  176. dest = datap->data;
  177. if (F_ISSET(qp, QAM_VALID))
  178. memcpy(dest, p, t->re_len);
  179. else
  180. memset(dest, t->re_pad, t->re_len);
  182. dest += data->doff;
  183. memcpy(dest, data->data, data->size);
  184. } else {
  185. datap = data;
  186. p += data->doff;
  187. }
  188. }
  190. no_partial:
  191. if (DB_LOGGING(dbc)) {
  192. olddata.size = 0;
  193. if (F_ISSET(qp, QAM_SET)) {
  194. olddata.data = qp->data;
  195. olddata.size = t->re_len;
  196. }
  197. if ((ret = __qam_add_log(dbp->dbenv, dbc->txn, &LSN(pagep),
  198.     0, dbp->log_fileid, &LSN(pagep), pagep->pgno,
  199.     indx, recno, datap, qp->flags,
  200.     olddata.size == 0 ? NULL : &olddata)) != 0)
  201. goto err;
  202. }
  204. F_SET(qp, QAM_VALID | QAM_SET);
  205. memcpy(p, datap->data, datap->size);
  206. if (!F_ISSET(data, DB_DBT_PARTIAL))
  207. memset(p + datap->size,  t->re_pad, t->re_len - datap->size);
  209. err: if (alloced)
  210. __os_free(datap->data, t->re_len);
  212. return (ret);
  213. }
  214. /*
  215.  * __qam_c_put
  216.  * Cursor put for queued access method.
  217.  * BEFORE and AFTER cannot be specified.
  218.  */
  219. static int
  220. __qam_c_put(dbc, key, data, flags, pgnop)
  221. DBC *dbc;
  222. DBT *key, *data;
  223. u_int32_t flags;
  224. db_pgno_t *pgnop;
  225. {
  226. QUEUE_CURSOR *cp;
  227. DB *dbp;
  228. DB_LOCK lock;
  229. QMETA *meta;
  230. db_pgno_t pg;
  231. db_recno_t new_cur, new_first;
  232. u_int32_t opcode;
  233. int exact, ret, t_ret;
  235. COMPQUIET(key, NULL);
  237. dbp = dbc->dbp;
  238. if (pgnop != NULL)
  239. *pgnop = PGNO_INVALID;
  241. cp = (QUEUE_CURSOR *)dbc->internal;
  243. /* Write lock the record. */
  244. if ((ret = __db_lget(dbc,
  245.     0, cp->recno, DB_LOCK_WRITE, DB_LOCK_RECORD, &lock)) != 0)
  246. return (ret);
  248. if ((ret = __qam_position(dbc,
  249.     &cp->recno, QAM_WRITE, &exact)) != 0) {
  250. /* We could not get the page, we can release the record lock. */
  251. __LPUT(dbc, lock);
  252. return (ret);
  253. }
  255. if (exact && flags == DB_NOOVERWRITE) {
  256. ret = __TLPUT(dbc, lock);
  257. /* Doing record locking, release the page lock */
  258. if ((t_ret = __LPUT(dbc, cp->lock)) == 0)
  259. cp->lock.off = LOCK_INVALID;
  260. else
  261. if (ret == 0)
  262. ret = t_ret;
  263. if ((t_ret =
  264.      __qam_fput(dbp, cp->pgno, cp->page, 0)) != 0 && ret == 0)
  265. ret = t_ret;
  266. cp->page = NULL;
  267. return (ret == 0 ? DB_KEYEXIST : ret);
  268. }
  270. /* Put the item on the page. */
  271. ret = __qam_pitem(dbc, (QPAGE *)cp->page, cp->indx, cp->recno, data);
  273. /* Doing record locking, release the page lock */
  274. if ((t_ret = __LPUT(dbc, cp->lock)) != 0 && ret == 0)
  275. ret = t_ret;
  276. if ((t_ret =
  277.     __qam_fput(dbp, cp->pgno, cp->page, DB_MPOOL_DIRTY)) && ret == 0)
  278. ret = t_ret;
  279. cp->page = NULL;
  280. cp->lock = lock;
  281. cp->lock_mode = DB_LOCK_WRITE;
  282. if (ret != 0)
  283. return (ret);
  285. /* We may need to reset the head or tail of the queue. */
  286. pg = ((QUEUE *)dbp->q_internal)->q_meta;
  287. if ((ret = __db_lget(dbc, 0, pg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  288. return (ret);
  289. if ((ret = memp_fget(dbp->mpf, &pg, 0, &meta)) != 0) {
  290. /* We did not fetch it, we can release the lock. */
  291. (void)__LPUT(dbc, lock);
  292. return (ret);
  293. }
  295. opcode = 0;
  296. new_cur = new_first = 0;
  298. /*
  299.  * If the put address is outside the queue, adjust the head and
  300.  * tail of the queue.  If the order is inverted we move
  301.  * the one which is closer.  The first case is when the
  302.  * queue is empty, move first and current to where the new
  303.  * insert is.
  304.  */
  306. if (meta->first_recno == meta->cur_recno) {
  307. new_first = cp->recno;
  308. new_cur = cp->recno + 1;
  309. if (new_cur == RECNO_OOB)
  310. new_cur++;
  311. opcode |= QAM_SETFIRST;
  312. opcode |= QAM_SETCUR;
  313. } else {
  314. if (QAM_BEFORE_FIRST(meta, cp->recno) &&
  315.     (meta->first_recno <= meta->cur_recno ||
  316.     meta->first_recno - cp->recno < cp->recno - meta->cur_recno)) {
  317. new_first = cp->recno;
  318. opcode |= QAM_SETFIRST;
  319. }
  321. if (meta->cur_recno == cp->recno ||
  322.     (QAM_AFTER_CURRENT(meta, cp->recno) &&
  323.     (meta->first_recno <= meta->cur_recno ||
  324.     cp->recno - meta->cur_recno <= meta->first_recno - cp->recno))) {
  325. new_cur = cp->recno + 1;
  326. if (new_cur == RECNO_OOB)
  327. new_cur++;
  328. opcode |= QAM_SETCUR;
  329. }
  330. }
  332. if (opcode != 0 && DB_LOGGING(dbc)) {
  333. ret = __qam_mvptr_log(dbp->dbenv, dbc->txn, &meta->dbmeta.lsn,
  334.     0, opcode, dbp->log_fileid, meta->first_recno, new_first,
  335.     meta->cur_recno, new_cur, &meta->dbmeta.lsn);
  336. }
  338. if (opcode & QAM_SETCUR)
  339. meta->cur_recno = new_cur;
  340. if (opcode & QAM_SETFIRST)
  341. meta->first_recno = new_first;
  343. if ((t_ret =
  344.     memp_fput(dbp->mpf, meta, opcode != 0 ? DB_MPOOL_DIRTY : 0)) != 0 &&
  345.     ret == 0)
  346. ret = t_ret;
  348. /* Don't hold the meta page long term. */
  349. if ((t_ret = __LPUT(dbc, lock)) != 0 && ret == 0)
  350. ret = t_ret;
  351. return (ret);
  352. }
  354. /*
  355.  * __qam_put --
  356.  * Add a record to the queue.
  357.  * If we are doing anything but appending, just call qam_c_put to do the
  358.  * work.  Otherwise we fast path things here.
  359.  *
  360.  * PUBLIC: int __qam_put __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
  361.  */
  362. int
  363. __qam_put(dbp, txn, key, data, flags)
  364. DB *dbp;
  365. DB_TXN *txn;
  366. DBT *key, *data;
  367. u_int32_t flags;
  368. {
  369. QUEUE_CURSOR *cp;
  370. DBC *dbc;
  371. DB_LOCK lock;
  372. QMETA *meta;
  373. QPAGE *page;
  374. QUEUE *qp;
  375. db_pgno_t pg;
  376. db_recno_t recno;
  377. int ret, t_ret;
  379. PANIC_CHECK(dbp->dbenv);
  380. DB_CHECK_TXN(dbp, txn);
  382. /* Allocate a cursor. */
  383. if ((ret = dbp->cursor(dbp, txn, &dbc, DB_WRITELOCK)) != 0)
  384. return (ret);
  386. DEBUG_LWRITE(dbc, dbc->txn, "qam_put", key, data, flags);
  388. cp = (QUEUE_CURSOR *)dbc->internal;
  390. /* Check for invalid flags. */
  391. if ((ret = __db_putchk(dbp,
  392.     key, data, flags, F_ISSET(dbp, DB_AM_RDONLY), 0)) != 0)
  393. goto done;
  395. /* If not appending, then just call the cursor routine */
  396. if (flags != DB_APPEND) {
  397. if ((ret = __qam_getno(dbp, key, &cp->recno)) != 0)
  398. goto done;
  400. ret = __qam_c_put(dbc, NULL, data, flags, NULL);
  401. goto done;
  402. }
  404. /* Write lock the meta page. */
  405. pg = ((QUEUE *)dbp->q_internal)->q_meta;
  406. if ((ret = __db_lget(dbc, 0, pg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  407. goto done;
  408. if ((ret = memp_fget(dbp->mpf, &pg, 0, &meta)) != 0) {
  409. /* We did not fetch it, we can release the lock. */
  410. (void)__LPUT(dbc, lock);
  411. goto done;
  412. }
  414. /* Record that we are going to allocate a record. */
  415. if (DB_LOGGING(dbc)) {
  416. __qam_inc_log(dbp->dbenv,
  417.     dbc->txn, &meta->dbmeta.lsn,
  418.     0, dbp->log_fileid, &meta->dbmeta.lsn);
  419. }
  421. /* Get the next record number. */
  422. recno = meta->cur_recno;
  423. meta->cur_recno++;
  424. if (meta->cur_recno == RECNO_OOB)
  425. meta->cur_recno++;
  426. if (meta->cur_recno == meta->first_recno) {
  427. meta->cur_recno--;
  428. if (meta->cur_recno == RECNO_OOB)
  429. meta->cur_recno--;
  430. (void)__LPUT(dbc, lock);
  431. ret = EFBIG;
  432. goto err;
  433. }
  435. if (QAM_BEFORE_FIRST(meta, recno))
  436. meta->first_recno = recno;
  438. /* Lock the record and release meta page lock. */
  439. if ((ret = __db_lget(dbc,
  440.     1, recno, DB_LOCK_WRITE, DB_LOCK_RECORD, &lock)) != 0)
  441. goto err;
  443. /*
  444.  * The application may modify the data based on the selected record
  445.  * number.
  446.  */
  447. if (flags == DB_APPEND && dbc->dbp->db_append_recno != NULL &&
  448.     (ret = dbc->dbp->db_append_recno(dbc->dbp, data, recno)) != 0) {
  449. (void)__LPUT(dbc, lock);
  450. goto err;
  451. }
  453. cp->lock = lock;
  454. cp->lock_mode = DB_LOCK_WRITE;
  456. pg = QAM_RECNO_PAGE(dbp, recno);
  458. /* Fetch and write lock the data page. */
  459. if ((ret = __db_lget(dbc, 0, pg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  460. goto err;
  461. if ((ret = __qam_fget(dbp, &pg, DB_MPOOL_CREATE, &page)) != 0) {
  462. /* We did not fetch it, we can release the lock. */
  463. (void)__LPUT(dbc, lock);
  464. goto err;
  465. }
  467. /* See if this is a new page. */
  468. if (page->pgno == 0) {
  469. page->pgno = pg;
  470. page->type = P_QAMDATA;
  471. }
  473. /* Put the item on the page and log it. */
  474. ret = __qam_pitem(dbc, page,
  475.     QAM_RECNO_INDEX(dbp, pg, recno), recno, data);
  477. /* Doing record locking, release the page lock */
  478. if ((t_ret = __LPUT(dbc, lock)) != 0 && ret == 0)
  479. ret = t_ret;
  481. if ((t_ret
  482.     = __qam_fput(dbp, pg, page, DB_MPOOL_DIRTY)) != 0 && ret == 0)
  483. ret = t_ret;
  485. /* Return the record number to the user. */
  486. if (ret == 0)
  487. ret = __db_retcopy(dbp, key,
  488.     &recno, sizeof(recno), &dbc->rkey.data, &dbc->rkey.ulen);
  490. /* See if we are leaving the extent. */
  491. qp = (QUEUE *) dbp->q_internal;
  492. if (qp->page_ext != 0
  493.     && (recno % (qp->page_ext * qp->rec_page) == 0
  494.     || recno == UINT32_T_MAX)) {
  495. if ((ret =
  496.     __db_lget(dbc, 0, pg,  DB_LOCK_WRITE, 0, &lock)) != 0)
  497. goto err;
  498. if (!QAM_AFTER_CURRENT(meta, recno))
  499. ret = __qam_fclose(dbp, pg);
  500. (void)__LPUT(dbc, lock);
  501. }
  503. err:
  504. /* Release the meta page. */
  505. if ((t_ret
  506.      = memp_fput(dbp->mpf, meta, DB_MPOOL_DIRTY)) != 0 && ret == 0)
  507. ret = t_ret;
  509. done:
  510. /* Discard the cursor. */
  511. if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  512. ret = t_ret;
  514. return (ret);
  515. }
  517. /*
  518.  * __qam_c_del --
  519.  * Qam cursor->am_del function
  520.  */
  521. static int
  522. __qam_c_del(dbc)
  523. DBC *dbc;
  524. {
  525. QUEUE_CURSOR *cp;
  526. DB *dbp;
  527. DBT data;
  528. DB_LOCK lock;
  529. PAGE *pagep;
  530. QAMDATA *qp;
  531. QMETA *meta;
  532. db_pgno_t pg;
  533. int exact, ret, t_ret;
  535. dbp = dbc->dbp;
  536. cp = (QUEUE_CURSOR *)dbc->internal;
  538. pg = ((QUEUE *)dbp->q_internal)->q_meta;
  539. if ((ret = __db_lget(dbc, 0, pg,  DB_LOCK_READ, 0, &lock)) != 0)
  540. return (ret);
  541. if ((ret = memp_fget(dbp->mpf, &pg, 0, &meta)) != 0) {
  542. /* We did not fetch it, we can release the lock. */
  543. (void)__LPUT(dbc, lock);
  544. return (ret);
  545. }
  547. if (QAM_NOT_VALID(meta, cp->recno))
  548. ret = DB_NOTFOUND;
  550. /* Don't hold the meta page long term. */
  551. if ((t_ret = __LPUT(dbc, lock)) != 0 && ret == 0)
  552. ret = t_ret;
  553. if ((t_ret = memp_fput(dbp->mpf, meta, 0)) != 0 && ret == 0)
  554. ret = t_ret;
  556. if (ret != 0)
  557. return (ret);
  559. if ((ret = __db_lget(dbc,
  560.     0, cp->recno, DB_LOCK_WRITE, DB_LOCK_RECORD, &lock)) != 0)
  561. return (ret);
  563. cp->lock_mode = DB_LOCK_WRITE;
  564. /* Find the record ; delete only deletes exact matches. */
  565. if ((ret = __qam_position(dbc,
  566.     &cp->recno, QAM_WRITE, &exact)) != 0) {
  567. cp->lock = lock;
  568. return (ret);
  569. }
  570. if (!exact) {
  571. ret = DB_NOTFOUND;
  572. goto err1;
  573. }
  575. pagep = cp->page;
  576. qp = QAM_GET_RECORD(dbp, pagep, cp->indx);
  578. if (DB_LOGGING(dbc)) {
  579. if (((QUEUE *)dbp->q_internal)->page_ext == 0
  580.     || ((QUEUE *)dbp->q_internal)->re_len == 0) {
  581. if ((ret =
  582.     __qam_del_log(dbp->dbenv,
  583.     dbc->txn, &LSN(pagep), 0,
  584.     dbp->log_fileid, &LSN(pagep),
  585.     pagep->pgno, cp->indx, cp->recno)) != 0)
  586. goto err1;
  587. } else {
  588. data.size = ((QUEUE *)dbp->q_internal)->re_len;
  589. data.data = qp->data;
  590. if ((ret =
  591.     __qam_delext_log(dbp->dbenv, dbc->txn,
  592.     &LSN(pagep), 0, dbp->log_fileid, &LSN(pagep),
  593.     pagep->pgno, cp->indx, cp->recno, &data)) != 0)
  594. goto err1;
  595. }
  596. }
  598. F_CLR(qp, QAM_VALID);
  600. err1:
  601. if ((t_ret = __qam_fput(
  602.     dbp, cp->pgno, cp->page, ret == 0 ? DB_MPOOL_DIRTY : 0)) != 0)
  603. return (ret ? ret : t_ret);
  604. cp->page = NULL;
  605. /* Doing record locking, release the page lock */
  606. if ((t_ret = __LPUT(dbc, cp->lock)) != 0) {
  607. cp->lock = lock;
  608. return (ret ? ret : t_ret);
  609. }
  610. cp->lock = lock;
  611. return (ret);
  612. }
  614. /*
  615.  * __qam_delete --
  616.  * Queue db->del function.
  617.  *
  618.  * PUBLIC: int __qam_delete __P((DB *, DB_TXN *, DBT *, u_int32_t));
  619.  */
  620. int
  621. __qam_delete(dbp, txn, key, flags)
  622. DB *dbp;
  623. DB_TXN *txn;
  624. DBT *key;
  625. u_int32_t flags;
  626. {
  627. QUEUE_CURSOR *cp;
  628. DBC *dbc;
  629. int ret, t_ret;
  631. PANIC_CHECK(dbp->dbenv);
  632. DB_CHECK_TXN(dbp, txn);
  634. /* Check for invalid flags. */
  635. if ((ret =
  636.     __db_delchk(dbp, key, flags, F_ISSET(dbp, DB_AM_RDONLY))) != 0)
  637. return (ret);
  639. /* Acquire a cursor. */
  640. if ((ret = dbp->cursor(dbp, txn, &dbc, DB_WRITELOCK)) != 0)
  641. return (ret);
  643. DEBUG_LWRITE(dbc, txn, "qam_delete", key, NULL, flags);
  645. cp = (QUEUE_CURSOR *)dbc->internal;
  646. if ((ret = __qam_getno(dbp, key, &cp->recno)) != 0)
  647. goto err;
  649. ret = __qam_c_del(dbc);
  651. /* Release the cursor. */
  652. err: if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
  653. ret = t_ret;
  655. return (ret);
  656. }
  658. #ifdef DEBUG_WOP
  659. #define QDEBUG
  660. #endif
  662. /*
  663.  * __qam_c_get --
  664.  * Queue cursor->c_get function.
  665.  */
  666. static int
  667. __qam_c_get(dbc, key, data, flags, pgnop)
  668. DBC *dbc;
  669. DBT *key, *data;
  670. u_int32_t flags;
  671. db_pgno_t *pgnop;
  672. {
  673. DB *dbp;
  674. DB_LOCK lock, pglock, metalock, save_lock;
  675. DBT tmp;
  676. PAGE *pg;
  677. QAMDATA *qp;
  678. QMETA *meta;
  679. QUEUE *t;
  680. QUEUE_CURSOR *cp;
  681. db_indx_t save_indx;
  682. db_lockmode_t lock_mode;
  683. db_pgno_t metapno, save_page;
  684. db_recno_t current, first, save_recno;
  685. qam_position_mode mode;
  686. u_int32_t rec_extent;
  687. int exact, is_first, locked, ret, t_ret, wait, with_delete;
  688. int put_mode, meta_dirty, retrying, skip_again, wrapped;
  690. cp = (QUEUE_CURSOR *)dbc->internal;
  691. dbp = dbc->dbp;
  693. PANIC_CHECK(dbp->dbenv);
  695. wait = 0;
  696. with_delete = 0;
  697. retrying = 0;
  698. rec_extent = 0;
  699. lock_mode = DB_LOCK_READ;
  700. mode = QAM_READ;
  701. put_mode = 0;
  702. t_ret = 0;
  703. *pgnop = 0;
  704. pg = NULL;
  705. skip_again = 0;
  707. if (F_ISSET(dbc, DBC_RMW)) {
  708. lock_mode = DB_LOCK_WRITE;
  709. mode = QAM_WRITE;
  710. }
  712. if (flags == DB_CONSUME_WAIT) {
  713. wait = 1;
  714. flags = DB_CONSUME;
  715. }
  716. if (flags == DB_CONSUME) {
  717. DB_CHECK_TXN(dbp, dbc->txn);
  718. with_delete = 1;
  719. flags = DB_FIRST;
  720. lock_mode = DB_LOCK_WRITE;
  721. mode = QAM_CONSUME;
  722. }
  724. DEBUG_LREAD(dbc, dbc->txn, "qam_c_get",
  725.     flags == DB_SET || flags == DB_SET_RANGE ? key : NULL, NULL, flags);
  727. is_first = 0;
  729. t = (QUEUE *)dbp->q_internal;
  730. /* get the meta page */
  731. metapno = t->q_meta;
  732. if ((ret = __db_lget(dbc, 0, metapno, lock_mode, 0, &metalock)) != 0)
  733. return (ret);
  734. locked = 1;
  735. if ((ret = memp_fget(dbp->mpf, &metapno, 0, &meta)) != 0) {
  736. /* We did not fetch it, we can release the lock. */
  737. (void)__LPUT(dbc, metalock);
  738. return (ret);
  739. }
  741. first = 0;
  743. /* Make lint and friends happy. */
  744. meta_dirty = 0;
  746. /* Release any previous lock if not in a transaction. */
  747. if (cp->lock.off != LOCK_INVALID) {
  748. (void)__TLPUT(dbc, cp->lock);
  749. cp->lock.off = LOCK_INVALID;
  750. }
  752. retry: /* Update the record number. */
  753. switch (flags) {
  754. case DB_CURRENT:
  755. break;
  756. case DB_NEXT_DUP:
  757. ret = DB_NOTFOUND;
  758. goto err;
  759. /* NOTREACHED */
  760. case DB_NEXT:
  761. case DB_NEXT_NODUP:
  762. if (cp->recno != RECNO_OOB) {
  763. ++cp->recno;
  764. /* Wrap around, skipping zero. */
  765. if (cp->recno == RECNO_OOB)
  766. cp->recno++;
  767. break;
  768. }
  769. /* FALLTHROUGH */
  770. case DB_FIRST:
  771. flags = DB_NEXT;
  772. is_first = 1;
  774. /* get the first record number */
  775. cp->recno = first = meta->first_recno;
  777. break;
  778. case DB_PREV:
  779. case DB_PREV_NODUP:
  780. if (cp->recno != RECNO_OOB) {
  781. if (QAM_BEFORE_FIRST(meta, cp->recno)
  782.     || cp->recno == meta->first_recno) {
  783. ret = DB_NOTFOUND;
  784. goto err;
  785. }
  786. --cp->recno;
  787. /* Wrap around, skipping zero. */
  788. if (cp->recno == RECNO_OOB)
  789. --cp->recno;
  790. break;
  791. }
  792. /* FALLTHROUGH */
  793. case DB_LAST:
  794. if (meta->first_recno == meta->cur_recno) {
  795. ret = DB_NOTFOUND;
  796. goto err;
  797. }
  798. cp->recno = meta->cur_recno - 1;
  799. if (cp->recno == RECNO_OOB)
  800. cp->recno--;
  801. break;
  802. case DB_GET_BOTH:
  803. case DB_SET:
  804. case DB_SET_RANGE:
  805. if ((ret = __qam_getno(dbp, key, &cp->recno)) != 0)
  806. goto err;
  807. break;
  808. default:
  809. ret = __db_unknown_flag(dbp->dbenv, "__qam_c_get", flags);
  810. goto err;
  811. }
  813. /*
  814.  * Check to see if we are out of data.  Current points to
  815.  * the first free slot.
  816.  */
  817. if (cp->recno == meta->cur_recno ||
  818.     QAM_AFTER_CURRENT(meta, cp->recno)) {
  819. ret = DB_NOTFOUND;
  820. pg = NULL;
  821. if (wait) {
  822. flags = DB_FIRST;
  823. /*
  824.  * If first is not set, then we skipped a
  825.  * locked record, go back and find it.
  826.  * If we find a locked record again
  827.  * wait for it.
  828.  */
  829. if (first == 0) {
  830. retrying = 1;
  831. goto retry;
  832. }
  833. if (CDB_LOCKING(dbp->dbenv)) {
  834. if ((ret = lock_get(dbp->dbenv, dbc->locker,
  835.     DB_LOCK_SWITCH, &dbc->lock_dbt,
  836.     DB_LOCK_WAIT, &dbc->mylock)) != 0)
  837. goto err;
  838. if ((ret = lock_get(dbp->dbenv, dbc->locker,
  839.     DB_LOCK_UPGRADE, &dbc->lock_dbt, DB_LOCK_WRITE,
  840.     &dbc->mylock)) != 0)
  841. goto err;
  842. goto retry;
  843. }
  844. /*
  845.  * Wait for someone to update the meta page.
  846.  * This will probably mean there is something
  847.  * in the queue.  We then go back up and
  848.  * try again.
  849.  */
  850. if (locked == 0) {
  851. if ((ret = __db_lget( dbc,
  852.     0, metapno, lock_mode, 0, &metalock)) != 0)
  853. goto err;
  854. locked = 1;
  855. if (cp->recno != RECNO_OOB &&
  856.     !QAM_AFTER_CURRENT(meta, cp->recno))
  857. goto retry;
  858. }
  859. if ((ret = __db_lget(dbc, 0, metapno,
  860.     DB_LOCK_WAIT, DB_LOCK_SWITCH, &metalock)) != 0)
  861. goto err;
  862. if ((ret = lock_get(dbp->dbenv, dbc->locker,
  863.     DB_LOCK_UPGRADE, &dbc->lock_dbt, DB_LOCK_WRITE,
  864.     &metalock)) != 0)
  865. goto err;
  866. locked = 1;
  867. goto retry;
  868. }
  870. goto err;
  871. }
  873. /* Don't hold the meta page long term. */
  874. if (locked) {
  875. if ((ret = __LPUT(dbc, metalock)) != 0)
  876. goto err;
  877. locked = 0;
  878. }
  880. /* Lock the record. */
  881. if ((ret = __db_lget(dbc, 0, cp->recno, lock_mode,
  882.     (with_delete && !retrying) ?
  883.     DB_LOCK_NOWAIT | DB_LOCK_RECORD : DB_LOCK_RECORD,
  884.     &lock)) == DB_LOCK_NOTGRANTED && with_delete) {
  885. #ifdef QDEBUG
  886. __db_logmsg(dbp->dbenv,
  887.     dbc->txn, "Queue S", 0, "%x %d %d %d",
  888.     dbc->locker, cp->recno, first, meta->first_recno);
  889. #endif
  890. first = 0;
  891. goto retry;
  892. }
  894. if (ret != 0)
  895. goto err;
  897. /*
  898.  * In the DB_FIRST or DB_LAST cases we must wait and then start over
  899.  * since the first/last may have moved while we slept.
  900.  * We release our locks and try again.
  901.  */
  902. if ((!with_delete && is_first) || flags == DB_LAST) {
  903. if ((ret =
  904.     __db_lget(dbc, 0, metapno, lock_mode, 0, &metalock)) != 0)
  905. goto err;
  906. if (cp->recno !=
  907.     (is_first ? meta->first_recno : (meta->cur_recno - 1))) {
  908. __LPUT(dbc, lock);
  909. if (is_first)
  910. flags = DB_FIRST;
  911. locked = 1;
  912. goto retry;
  913. }
  914. /* Don't hold the meta page long term. */
  915. if ((ret = __LPUT(dbc, metalock)) != 0)
  916. goto err;
  917. }
  919. /* Position the cursor on the record. */
  920. if ((ret = __qam_position(dbc, &cp->recno, mode, &exact)) != 0) {
  921. /* We cannot get the page, release the record lock. */
  922. (void)__LPUT(dbc, lock);
  923. goto err;
  924. }
  926. pg = cp->page;
  927. pglock = cp->lock;
  928. cp->lock = lock;
  929. cp->lock_mode = lock_mode;
  931. if (!exact) {
  932. if (flags == DB_NEXT || flags == DB_NEXT_NODUP
  933.     || flags == DB_PREV || flags == DB_PREV_NODUP
  934.     || flags == DB_LAST) {
  935. /* Release locks and try again. */
  936. if (pg != NULL)
  937. (void)__qam_fput(dbp, cp->pgno, pg, 0);
  938. cp->page = pg = NULL;
  939. (void)__LPUT(dbc, pglock);
  940. (void)__LPUT(dbc, cp->lock);
  941. if (flags == DB_LAST)
  942. flags = DB_PREV;
  943. if (!with_delete)
  944. is_first = 0;
  945. retrying = 0;
  946. goto retry;
  947. }
  948. /* this is for the SET and SET_RANGE cases */
  949. ret = DB_KEYEMPTY;
  950. goto err1;
  951. }
  953. /* Return the key if the user didn't give us one. */
  954. if (key != NULL && flags != DB_SET && flags != DB_GET_BOTH &&
  955.     (ret = __db_retcopy(dbp, key, &cp->recno, sizeof(cp->recno),
  956.     &dbc->rkey.data, &dbc->rkey.ulen)) != 0)
  957. goto err1;
  959. if (key != NULL)
  960. F_SET(key, DB_DBT_ISSET);
  962. qp = QAM_GET_RECORD(dbp, pg, cp->indx);
  964. /* Return the data item. */
  965. if (flags == DB_GET_BOTH) {
  966. /*
  967.  * Need to compare
  968.  */
  969. tmp.data = qp->data;
  970. tmp.size = t->re_len;
  971. if ((ret = __bam_defcmp(dbp, data, &tmp)) != 0) {
  972. ret = DB_NOTFOUND;
  973. goto err1;
  974. }
  975. }
  976. if (data != NULL && (ret = __db_retcopy(dbp, data,
  977.     qp->data, t->re_len, &dbc->rdata.data, &dbc->rdata.ulen)) != 0)
  978. goto err1;
  980. if (data != NULL)
  981. F_SET(data, DB_DBT_ISSET);
  983. /* Finally, if we are doing DB_CONSUME mark the record. */
  984. if (with_delete) {
  985. if (DB_LOGGING(dbc)) {
  986. if (t->page_ext == 0 || t->re_len == 0) {
  987. if ((ret = __qam_del_log(dbp->dbenv, dbc->txn,
  988.     &LSN(pg), 0, dbp->log_fileid, &LSN(pg),
  989.     pg->pgno, cp->indx, cp->recno)) != 0)
  990. goto err1;
  991. } else {
  992. tmp.data = qp->data;
  993. tmp.size = t->re_len;
  994. if ((ret =
  995.    __qam_delext_log(dbp->dbenv, dbc->txn,
  996.    &LSN(pg), 0, dbp->log_fileid, &LSN(pg),
  997.    pg->pgno, cp->indx, cp->recno, &tmp)) != 0)
  998. goto err1;
  999. }
  1000. }
  1002. F_CLR(qp, QAM_VALID);
  1003. put_mode = DB_MPOOL_DIRTY;
  1005. if ((ret = __LPUT(dbc, pglock)) != 0)
  1006. goto err;
  1008. /*
  1009.  * Now we need to update the metapage
  1010.  * first pointer. If we have deleted
  1011.  * the record that is pointed to by
  1012.  * first_recno then we move it as far
  1013.  * forward as we can without blocking.
  1014.  * The metapage lock must be held for
  1015.  * the whole scan otherwise someone could
  1016.  * do a random insert behind where we are
  1017.  * looking.
  1018.  */
  1020. if (locked == 0 && (ret = __db_lget(
  1021.     dbc, 0, metapno, lock_mode, 0, &metalock)) != 0)
  1022. goto err1;
  1023. locked = 1;
  1024. #ifdef QDEBUG
  1025. __db_logmsg(dbp->dbenv,
  1026.     dbc->txn, "Queue D", 0, "%x %d %d %d",
  1027.     dbc->locker, cp->recno, first, meta->first_recno);
  1028. #endif
  1029. /*
  1030.  * See if we deleted the "first" record.  If
  1031.  * first is zero then we skipped something,
  1032.  * see if first_recno has been move passed
  1033.  * that to the record that we deleted.
  1034.  */
  1035. if (first == 0)
  1036. first = cp->recno;
  1037. if (first != meta->first_recno)
  1038. goto done;
  1040. save_page = cp->pgno;
  1041. save_indx = cp->indx;
  1042. save_recno = cp->recno;
  1043. save_lock = cp->lock;
  1045. /*
  1046.  * If we skipped some deleted records, we need to
  1047.  * reposition on the first one.  Get a lock
  1048.  * in case someone is trying to put it back.
  1049.  */
  1050. if (first != cp->recno) {
  1051. ret = __db_lget(dbc, 0, first, DB_LOCK_READ,
  1052.     DB_LOCK_NOWAIT | DB_LOCK_RECORD, &lock);
  1053. if (ret == DB_LOCK_NOTGRANTED) {
  1054. ret = 0;
  1055. goto done;
  1056. }
  1057. if (ret != 0)
  1058. goto err1;
  1059. if ((ret =
  1060.     __qam_fput(dbp, cp->pgno, cp->page, put_mode)) != 0)
  1061. goto err1;
  1062. cp->page = NULL;
  1063. put_mode = 0;
  1064. if ((ret = __qam_position(dbc,
  1065.     &first, QAM_READ, &exact)) != 0 || exact != 0) {
  1066. (void)__LPUT(dbc, lock);
  1067. goto err1;
  1068. }
  1069. if ((ret =__LPUT(dbc, lock)) != 0)
  1070. goto err1;
  1071. if ((ret = __LPUT(dbc, cp->lock)) != 0)
  1072. goto err1;
  1073. }
  1075. current = meta->cur_recno;
  1076. wrapped = 0;
  1077. if (first > current)
  1078. wrapped = 1;
  1079. rec_extent = meta->page_ext * meta->rec_page;
  1081. /* Loop until we find a record or hit current */
  1082. for (;;) {
  1083. /*
  1084.  * Check to see if we are moving off the extent
  1085.  * and remove the extent.
  1086.  * If we are moving off a page we need to
  1087.  * get rid of the buffer.
  1088.  * Wait for the lagging readers to move off the
  1089.  * page.
  1090.  */
  1091. if (rec_extent != 0
  1092.     && ((exact = first % rec_extent == 0)
  1093.     || first % meta->rec_page == 0
  1094.     || first == UINT32_T_MAX)) {
  1095. if (exact == 1 && (ret = __db_lget(dbc,
  1096.     0, cp->pgno, DB_LOCK_WRITE, 0, &cp->lock)) != 0)
  1097. break;
  1099. #ifdef QDEBUG
  1100. __db_logmsg(dbp->dbenv,
  1101.     dbc->txn, "Queue R", 0, "%x %d %d %d",
  1102.     dbc->locker, cp->pgno, first, meta->first_recno);
  1103. #endif
  1104. put_mode |= DB_MPOOL_DISCARD;
  1105. if ((ret = __qam_fput(dbp,
  1106.     cp->pgno, cp->page, put_mode)) != 0)
  1107. break;
  1108. cp->page = NULL;
  1110. if (exact == 1) {
  1111. ret = __qam_fremove(dbp, cp->pgno);
  1112. t_ret = __LPUT(dbc, cp->lock);
  1113. }
  1114. if (ret != 0)
  1115. break;
  1116. if (t_ret != 0) {
  1117. ret = t_ret;
  1118. break;
  1119. }
  1120. } else if ((ret =
  1121.     __qam_fput(dbp, cp->pgno, cp->page, put_mode)) != 0)
  1122. break;
  1123. cp->page = NULL;
  1124. first++;
  1125. if (first == RECNO_OOB) {
  1126. wrapped = 0;
  1127. first++;
  1128. }
  1130. /*
  1131.  * LOOP EXIT when we come move to the current
  1132.  * pointer.
  1133.  */
  1134. if (!wrapped && first >= current)
  1135. break;
  1137. ret = __db_lget(dbc, 0, first, DB_LOCK_READ,
  1138.     DB_LOCK_NOWAIT | DB_LOCK_RECORD, &lock);
  1139. if (ret == DB_LOCK_NOTGRANTED) {
  1140. ret = 0;
  1141. break;
  1142. }
  1143. if (ret != 0)
  1144. break;
  1146. if ((ret = __qam_position(dbc,
  1147.     &first, QAM_READ, &exact)) != 0) {
  1148. (void)__LPUT(dbc, lock);
  1149. break;
  1150. }
  1151. put_mode = 0;
  1152. if ((ret =__LPUT(dbc, lock)) != 0
  1153.     || (ret = __LPUT(dbc, cp->lock)) != 0 ||exact) {
  1154. if ((t_ret = __qam_fput(dbp, cp->pgno,
  1155.     cp->page, put_mode)) != 0 && ret == 0)
  1156. ret = t_ret;
  1157. cp->page = NULL;
  1158. break;
  1159. }
  1160. }
  1162. cp->pgno = save_page;
  1163. cp->indx = save_indx;
  1164. cp->recno = save_recno;
  1165. cp->lock = save_lock;
  1167. /*
  1168.  * We have advanced as far as we can.
  1169.  * Advance first_recno to this point.
  1170.  */
  1171. if (meta->first_recno != first) {
  1172. #ifdef QDEBUG
  1173. __db_logmsg(dbp->dbenv, dbc->txn, "Queue M",
  1174.     0, "%x %d %d %d", dbc->locker, cp->recno,
  1175.     first, meta->first_recno);
  1176. #endif
  1177. if (DB_LOGGING(dbc))
  1178. if ((ret =
  1179.      __qam_incfirst_log(dbp->dbenv,
  1180.      dbc->txn, &meta->dbmeta.lsn, 0,
  1181.      dbp->log_fileid, cp->recno)) != 0)
  1182. goto err;
  1183. meta->first_recno = first;
  1184. meta_dirty = 1;
  1185. }
  1186. }
  1188. done:
  1189. err1: if (cp->page != NULL) {
  1190. t_ret = __qam_fput(dbp, cp->pgno, cp->page, put_mode);
  1192. if (!ret)
  1193. ret = t_ret;
  1194. /* Doing record locking, release the page lock */
  1195. t_ret = __LPUT(dbc, pglock);
  1196. cp->page = NULL;
  1197. }
  1199. err: if (!ret)
  1200. ret = t_ret;
  1201. if (meta) {
  1203. /* release the meta page */
  1204. t_ret = memp_fput(
  1205.     dbp->mpf, meta, meta_dirty ? DB_MPOOL_DIRTY : 0);
  1207. if (!ret)
  1208. ret = t_ret;
  1210. /* Don't hold the meta page long term. */
  1211. if (locked)
  1212. t_ret = __LPUT(dbc, metalock);
  1213. }
  1214. DB_ASSERT(metalock.off == LOCK_INVALID);
  1216. /*
  1217.  * There is no need to keep the record locked if we are
  1218.  * not in a transaction.
  1219.  */
  1220. if (t_ret == 0)
  1221. t_ret = __TLPUT(dbc, cp->lock);
  1223. return (ret ? ret : t_ret);
  1224. }
  1226. /*
  1227.  * __qam_c_close --
  1228.  * Close down the cursor from a single use.
  1229.  */
  1230. static int
  1231. __qam_c_close(dbc, root_pgno, rmroot)
  1232. DBC *dbc;
  1233. db_pgno_t root_pgno;
  1234. int *rmroot;
  1235. {
  1236. QUEUE_CURSOR *cp;
  1238. COMPQUIET(root_pgno, 0);
  1239. COMPQUIET(rmroot, NULL);
  1241. cp = (QUEUE_CURSOR *)dbc->internal;
  1243. /* Discard any locks not acquired inside of a transaction. */
  1244. if (cp->lock.off != LOCK_INVALID) {
  1245. (void)__TLPUT(dbc, cp->lock);
  1246. cp->lock.off = LOCK_INVALID;
  1247. }
  1249. cp->page = NULL;
  1250. cp->pgno = PGNO_INVALID;
  1251. cp->indx = 0;
  1252. cp->lock.off = LOCK_INVALID;
  1253. cp->lock_mode = DB_LOCK_NG;
  1254. cp->recno = RECNO_OOB;
  1255. cp->flags = 0;
  1257. return (0);
  1258. }
  1260. /*
  1261.  * __qam_c_dup --
  1262.  * Duplicate a queue cursor, such that the new one holds appropriate
  1263.  * locks for the position of the original.
  1264.  *
  1265.  * PUBLIC: int __qam_c_dup __P((DBC *, DBC *));
  1266.  */
  1267. int
  1268. __qam_c_dup(orig_dbc, new_dbc)
  1269. DBC *orig_dbc, *new_dbc;
  1270. {
  1271. QUEUE_CURSOR *orig, *new;
  1273. orig = (QUEUE_CURSOR *)orig_dbc->internal;
  1274. new = (QUEUE_CURSOR *)new_dbc->internal;
  1276. new->recno = orig->recno;
  1278. /* reget the long term lock if we are not in a xact */
  1279. if (orig_dbc->txn != NULL ||
  1280.     !STD_LOCKING(orig_dbc) || orig->lock.off == LOCK_INVALID)
  1281. return (0);
  1283. return (__db_lget(new_dbc,
  1284.     0, new->recno, new->lock_mode, DB_LOCK_RECORD, &new->lock));
  1285. }
  1287. /*
  1288.  * __qam_c_init
  1289.  *
  1290.  * PUBLIC: int __qam_c_init __P((DBC *));
  1291.  */
  1292. int
  1293. __qam_c_init(dbc)
  1294. DBC *dbc;
  1295. {
  1296. QUEUE_CURSOR *cp;
  1297. DB *dbp;
  1298. int ret;
  1300. dbp = dbc->dbp;
  1302. /* Allocate the internal structure. */
  1303. cp = (QUEUE_CURSOR *)dbc->internal;
  1304. if (cp == NULL) {
  1305. if ((ret =
  1306.     __os_calloc(dbp->dbenv, 1, sizeof(QUEUE_CURSOR), &cp)) != 0)
  1307. return (ret);
  1308. dbc->internal = (DBC_INTERNAL *)cp;
  1309. }
  1311. /* Initialize methods. */
  1312. dbc->c_close = __db_c_close;
  1313. dbc->c_count = __db_c_count;
  1314. dbc->c_del = __db_c_del;
  1315. dbc->c_dup = __db_c_dup;
  1316. dbc->c_get = __db_c_get;
  1317. dbc->c_put = __db_c_put;
  1318. dbc->c_am_close = __qam_c_close;
  1319. dbc->c_am_del = __qam_c_del;
  1320. dbc->c_am_destroy = __qam_c_destroy;
  1321. dbc->c_am_get = __qam_c_get;
  1322. dbc->c_am_put = __qam_c_put;
  1323. dbc->c_am_writelock = NULL;
  1325. return (0);
  1326. }
  1328. /*
  1329.  * __qam_c_destroy --
  1330.  * Close a single cursor -- internal version.
  1331.  */
  1332. static int
  1333. __qam_c_destroy(dbc)
  1334. DBC *dbc;
  1335. {
  1336. /* Discard the structures. */
  1337. __os_free(dbc->internal, sizeof(QUEUE_CURSOR));
  1339. return (0);
  1340. }
  1342. /*
  1343.  * __qam_getno --
  1344.  * Check the user's record number.
  1345.  */
  1346. static int
  1347. __qam_getno(dbp, key, rep)
  1348. DB *dbp;
  1349. const DBT *key;
  1350. db_recno_t *rep;
  1351. {
  1352. if ((*rep = *(db_recno_t *)key->data) == 0) {
  1353. __db_err(dbp->dbenv, "illegal record number of 0");
  1354. return (EINVAL);
  1355. }
  1356. return (0);
  1357. }