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

MySQL数据库

开发平台:

Visual C++

  1. /*-
  2.  * See the file LICENSE for redistribution information.
  3.  *
  4.  * Copyright (c) 1996-2002
  5.  * Sleepycat Software.  All rights reserved.
  6.  */
  7. #include "db_config.h"
  8. #ifndef lint
  9. static const char revid[] = "$Id: db_ret.c,v 11.21 2002/03/28 19:21:47 bostic Exp $";
  10. #endif /* not lint */
  11. #ifndef NO_SYSTEM_INCLUDES
  12. #include <sys/types.h>
  13. #include <string.h>
  14. #endif
  15. #include "db_int.h"
  16. #include "dbinc/db_page.h"
  17. #include "dbinc/db_am.h"
  18. /*
  19.  * __db_ret --
  20.  * Build return DBT.
  21.  *
  22.  * PUBLIC: int __db_ret __P((DB *,
  23.  * PUBLIC:    PAGE *, u_int32_t, DBT *, void **, u_int32_t *));
  24.  */
  25. int
  26. __db_ret(dbp, h, indx, dbt, memp, memsize)
  27. DB *dbp;
  28. PAGE *h;
  29. u_int32_t indx;
  30. DBT *dbt;
  31. void **memp;
  32. u_int32_t *memsize;
  33. {
  34. BKEYDATA *bk;
  35. HOFFPAGE ho;
  36. BOVERFLOW *bo;
  37. u_int32_t len;
  38. u_int8_t *hk;
  39. void *data;
  40. switch (TYPE(h)) {
  41. case P_HASH:
  42. hk = P_ENTRY(dbp, h, indx);
  43. if (HPAGE_PTYPE(hk) == H_OFFPAGE) {
  44. memcpy(&ho, hk, sizeof(HOFFPAGE));
  45. return (__db_goff(dbp, dbt,
  46.     ho.tlen, ho.pgno, memp, memsize));
  47. }
  48. len = LEN_HKEYDATA(dbp, h, dbp->pgsize, indx);
  49. data = HKEYDATA_DATA(hk);
  50. break;
  51. case P_LBTREE:
  52. case P_LDUP:
  53. case P_LRECNO:
  54. bk = GET_BKEYDATA(dbp, h, indx);
  55. if (B_TYPE(bk->type) == B_OVERFLOW) {
  56. bo = (BOVERFLOW *)bk;
  57. return (__db_goff(dbp, dbt,
  58.     bo->tlen, bo->pgno, memp, memsize));
  59. }
  60. len = bk->len;
  61. data = bk->data;
  62. break;
  63. default:
  64. return (__db_pgfmt(dbp->dbenv, h->pgno));
  65. }
  66. return (__db_retcopy(dbp->dbenv, dbt, data, len, memp, memsize));
  67. }
  68. /*
  69.  * __db_retcopy --
  70.  * Copy the returned data into the user's DBT, handling special flags.
  71.  *
  72.  * PUBLIC: int __db_retcopy __P((DB_ENV *, DBT *,
  73.  * PUBLIC:    void *, u_int32_t, void **, u_int32_t *));
  74.  */
  75. int
  76. __db_retcopy(dbenv, dbt, data, len, memp, memsize)
  77. DB_ENV *dbenv;
  78. DBT *dbt;
  79. void *data;
  80. u_int32_t len;
  81. void **memp;
  82. u_int32_t *memsize;
  83. {
  84. int ret;
  85. /* If returning a partial record, reset the length. */
  86. if (F_ISSET(dbt, DB_DBT_PARTIAL)) {
  87. data = (u_int8_t *)data + dbt->doff;
  88. if (len > dbt->doff) {
  89. len -= dbt->doff;
  90. if (len > dbt->dlen)
  91. len = dbt->dlen;
  92. } else
  93. len = 0;
  94. }
  95. /*
  96.  * Return the length of the returned record in the DBT size field.
  97.  * This satisfies the requirement that if we're using user memory
  98.  * and insufficient memory was provided, return the amount necessary
  99.  * in the size field.
  100.  */
  101. dbt->size = len;
  102. /*
  103.  * Allocate memory to be owned by the application: DB_DBT_MALLOC,
  104.  * DB_DBT_REALLOC.
  105.  *
  106.  * !!!
  107.  * We always allocate memory, even if we're copying out 0 bytes. This
  108.  * guarantees consistency, i.e., the application can always free memory
  109.  * without concern as to how many bytes of the record were requested.
  110.  *
  111.  * Use the memory specified by the application: DB_DBT_USERMEM.
  112.  *
  113.  * !!!
  114.  * If the length we're going to copy is 0, the application-supplied
  115.  * memory pointer is allowed to be NULL.
  116.  */
  117. if (F_ISSET(dbt, DB_DBT_MALLOC)) {
  118. if ((ret = __os_umalloc(dbenv, len, &dbt->data)) != 0)
  119. return (ret);
  120. } else if (F_ISSET(dbt, DB_DBT_REALLOC)) {
  121. if ((ret = __os_urealloc(dbenv, len, &dbt->data)) != 0)
  122. return (ret);
  123. } else if (F_ISSET(dbt, DB_DBT_USERMEM)) {
  124. if (len != 0 && (dbt->data == NULL || dbt->ulen < len))
  125. return (ENOMEM);
  126. } else if (memp == NULL || memsize == NULL) {
  127. return (EINVAL);
  128. } else {
  129. if (len != 0 && (*memsize == 0 || *memsize < len)) {
  130. if ((ret = __os_realloc(dbenv, len, memp)) != 0) {
  131. *memsize = 0;
  132. return (ret);
  133. }
  134. *memsize = len;
  135. }
  136. dbt->data = *memp;
  137. }
  138. if (len != 0)
  139. memcpy(dbt->data, data, len);
  140. return (0);
  141. }