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

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

MySQL数据库

开发平台：

Visual C++

BerkeleyDB.xs：源码内容
  1. /*
  3.  BerkeleyDB.xs -- Perl 5 interface to Berkeley DB version 2 & 3
  5.  written by Paul Marquess <Paul.Marquess@btinternet.com>
  7.  All comments/suggestions/problems are welcome
  9.      Copyright (c) 1997-2001 Paul Marquess. All rights reserved.
  10.      This program is free software; you can redistribute it and/or
  11.      modify it under the same terms as Perl itself.
  13.      Please refer to the COPYRIGHT section in
  15.  Changes:
  16.         0.01 -  First Alpha Release
  17.         0.02 -
  19. */
  23. #ifdef __cplusplus
  24. extern "C" {
  25. #endif
  26. #define PERL_POLLUTE
  27. #include "EXTERN.h"
  28. #include "perl.h"
  29. #include "XSUB.h"
  31. /* Being the Berkeley DB we prefer the <sys/cdefs.h> (which will be
  32.  * shortly #included by the <db.h>) __attribute__ to the possibly
  33.  * already defined __attribute__, for example by GNUC or by Perl. */
  35. #undef __attribute__
  37. #ifndef PERL_VERSION
  38. #    include "patchlevel.h"
  39. #    define PERL_REVISION 5
  40. #    define PERL_VERSION PATCHLEVEL
  41. #    define PERL_SUBVERSION SUBVERSION
  42. #endif
  44. #if PERL_REVISION == 5 && (PERL_VERSION < 4 || (PERL_VERSION == 4 && PERL_SUBVERSION <= 75 ))
  46. #    define PL_sv_undef sv_undef
  47. #    define PL_na na
  48. #    define PL_dirty dirty
  50. #endif
  52. #include <db.h>
  54. #if (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR == 0)
  55. #  define IS_DB_3_0
  56. #endif
  58. #if DB_VERSION_MAJOR >= 3
  59. #  define AT_LEAST_DB_3
  60. #endif
  62. #if DB_VERSION_MAJOR > 3 || (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR >= 1)
  63. #  define AT_LEAST_DB_3_1
  64. #endif
  66. #if DB_VERSION_MAJOR > 3 || (DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR >= 2)
  67. #  define AT_LEAST_DB_3_2
  68. #endif
  70. /* need to define DEFSV & SAVE_DEFSV for older version of Perl */
  71. #ifndef DEFSV
  72. #    define DEFSV GvSV(defgv)
  73. #endif
  75. #ifndef SAVE_DEFSV
  76. #    define SAVE_DEFSV SAVESPTR(GvSV(defgv))
  77. #endif
  79. #ifndef pTHX
  80. #    define pTHX
  81. #    define pTHX_
  82. #    define aTHX
  83. #    define aTHX_
  84. #endif
  86. #ifndef dTHR
  87. #    define dTHR
  88. #endif
  90. #ifndef newSVpvn
  91. #    define newSVpvn(a,b)       newSVpv(a,b)
  92. #endif
  94. #ifdef __cplusplus
  95. }
  96. #endif
  98. #define DBM_FILTERING
  99. #define STRICT_CLOSE
  100. /* #define ALLOW_RECNO_OFFSET */
  101. /* #define TRACE */
  103. #if DB_VERSION_MAJOR == 2 && ! defined(DB_LOCK_DEADLOCK)
  104. #  define DB_LOCK_DEADLOCK EAGAIN
  105. #endif /* DB_VERSION_MAJOR == 2 */
  107. #if DB_VERSION_MAJOR == 2
  108. #  define DB_QUEUE 4
  109. #endif /* DB_VERSION_MAJOR == 2 */
  111. #ifdef AT_LEAST_DB_3_2
  112. #    define DB_callback DB * db,
  113. #else
  114. #    define DB_callback
  115. #endif
  117. #if DB_VERSION_MAJOR > 2
  118. typedef struct {
  119.         int              db_lorder;
  120.         size_t           db_cachesize;
  121.         size_t           db_pagesize;
  124.         void *(*db_malloc) __P((size_t));
  125.         int (*dup_compare)
  126.             __P((DB_callback const DBT *, const DBT *));
  128.         u_int32_t        bt_maxkey;
  129.         u_int32_t        bt_minkey;
  130.         int (*bt_compare)
  131.             __P((DB_callback const DBT *, const DBT *));
  132.         size_t (*bt_prefix)
  133.             __P((DB_callback const DBT *, const DBT *));
  135.         u_int32_t        h_ffactor;
  136.         u_int32_t        h_nelem;
  137.         u_int32_t      (*h_hash)
  138.             __P((DB_callback const void *, u_int32_t));
  140.         int              re_pad;
  141.         int              re_delim;
  142.         u_int32_t        re_len;
  143.         char            *re_source;
  145. #define DB_DELIMITER            0x0001
  146. #define DB_FIXEDLEN             0x0008
  147. #define DB_PAD                  0x0010
  148.         u_int32_t        flags;
  149.         u_int32_t        q_extentsize;
  150. } DB_INFO ;
  152. #endif /* DB_VERSION_MAJOR > 2 */
  154. typedef struct {
  155. int Status ;
  156. /* char ErrBuff[1000] ; */
  157. SV * ErrPrefix ;
  158. SV * ErrHandle ;
  159. DB_ENV * Env ;
  160. int open_dbs ;
  161. int TxnMgrStatus ;
  162. int active ;
  163. bool txn_enabled ;
  164. } BerkeleyDB_ENV_type ;
  167. typedef struct {
  168.         DBTYPE   type ;
  169. bool recno_or_queue ;
  170. char * filename ;
  171. BerkeleyDB_ENV_type * parent_env ;
  172.         DB *     dbp ;
  173.         SV *     compare ;
  174.         SV *     dup_compare ;
  175.         SV *     prefix ;
  176.         SV *      hash ;
  177. int Status ;
  178.         DB_INFO * info ;
  179.         DBC *    cursor ;
  180. DB_TXN * txn ;
  181. int open_cursors ;
  182. u_int32_t partial ;
  183. u_int32_t dlen ;
  184. u_int32_t doff ;
  185. int active ;
  186. #ifdef ALLOW_RECNO_OFFSET
  187. int array_base ;
  188. #endif
  189. #ifdef DBM_FILTERING
  190.         SV *    filter_fetch_key ;
  191.         SV *    filter_store_key ;
  192.         SV *    filter_fetch_value ;
  193.         SV *    filter_store_value ;
  194.         int     filtering ;
  195. #endif
  196.         } BerkeleyDB_type;
  199. typedef struct {
  200.         DBTYPE   type ;
  201. bool recno_or_queue ;
  202. char * filename ;
  203.         DB *     dbp ;
  204.         SV *     compare ;
  205.         SV *     dup_compare ;
  206.         SV *     prefix ;
  207.         SV *      hash ;
  208. int Status ;
  209.         DB_INFO * info ;
  210.         DBC *    cursor ;
  211. DB_TXN * txn ;
  212. BerkeleyDB_type * parent_db ;
  213. u_int32_t partial ;
  214. u_int32_t dlen ;
  215. u_int32_t doff ;
  216. int active ;
  217. #ifdef ALLOW_RECNO_OFFSET
  218. int array_base ;
  219. #endif
  220. #ifdef DBM_FILTERING
  221.         SV *    filter_fetch_key ;
  222.         SV *    filter_store_key ;
  223.         SV *    filter_fetch_value ;
  224.         SV *    filter_store_value ;
  225.         int     filtering ;
  226. #endif
  227.         } BerkeleyDB_Cursor_type;
  229. typedef struct {
  230. BerkeleyDB_ENV_type * env ;
  231. } BerkeleyDB_TxnMgr_type ;
  233. #if 1
  234. typedef struct {
  235. int Status ;
  236. DB_TXN * txn ;
  237. int active ;
  238. } BerkeleyDB_Txn_type ;
  239. #else
  240. typedef DB_TXN                BerkeleyDB_Txn_type ;
  241. #endif
  243. typedef BerkeleyDB_ENV_type * BerkeleyDB__Env ;
  244. typedef BerkeleyDB_ENV_type * BerkeleyDB__Env__Raw ;
  245. typedef BerkeleyDB_ENV_type * BerkeleyDB__Env__Inner ;
  246. typedef BerkeleyDB_type *  BerkeleyDB ;
  247. typedef void *  BerkeleyDB__Raw ;
  248. typedef BerkeleyDB_type * BerkeleyDB__Common ;
  249. typedef BerkeleyDB_type * BerkeleyDB__Common__Raw ;
  250. typedef BerkeleyDB_type * BerkeleyDB__Common__Inner ;
  251. typedef BerkeleyDB_type *  BerkeleyDB__Hash ;
  252. typedef BerkeleyDB_type *  BerkeleyDB__Hash__Raw ;
  253. typedef BerkeleyDB_type *  BerkeleyDB__Btree ;
  254. typedef BerkeleyDB_type *  BerkeleyDB__Btree__Raw ;
  255. typedef BerkeleyDB_type *  BerkeleyDB__Recno ;
  256. typedef BerkeleyDB_type *  BerkeleyDB__Recno__Raw ;
  257. typedef BerkeleyDB_type *  BerkeleyDB__Queue ;
  258. typedef BerkeleyDB_type *  BerkeleyDB__Queue__Raw ;
  259. typedef BerkeleyDB_Cursor_type    BerkeleyDB__Cursor_type ;
  260. typedef BerkeleyDB_Cursor_type *  BerkeleyDB__Cursor ;
  261. typedef BerkeleyDB_Cursor_type *  BerkeleyDB__Cursor__Raw ;
  262. typedef BerkeleyDB_TxnMgr_type * BerkeleyDB__TxnMgr ;
  263. typedef BerkeleyDB_TxnMgr_type * BerkeleyDB__TxnMgr__Raw ;
  264. typedef BerkeleyDB_TxnMgr_type * BerkeleyDB__TxnMgr__Inner ;
  265. typedef BerkeleyDB_Txn_type * BerkeleyDB__Txn ;
  266. typedef BerkeleyDB_Txn_type * BerkeleyDB__Txn__Raw ;
  267. typedef BerkeleyDB_Txn_type * BerkeleyDB__Txn__Inner ;
  268. #if 0
  269. typedef DB_LOG *       BerkeleyDB__Log ;
  270. typedef DB_LOCKTAB *   BerkeleyDB__Lock ;
  271. #endif
  272. typedef DBT  DBTKEY ;
  273. typedef DBT  DBT_OPT ;
  274. typedef DBT  DBT_B ;
  275. typedef DBT  DBTKEY_B ;
  276. typedef DBT  DBTVALUE ;
  277. typedef void *        PV_or_NULL ;
  278. typedef PerlIO *       IO_or_NULL ;
  279. typedef int DualType ;
  281. static void
  282. hash_delete(char * hash, IV key);
  284. #ifdef TRACE
  285. #  define Trace(x) printf x
  286. #else
  287. #  define Trace(x)
  288. #endif
  290. #ifdef ALLOW_RECNO_OFFSET
  291. #  define RECNO_BASE db->array_base
  292. #else
  293. #  define RECNO_BASE 1
  294. #endif
  296. #if DB_VERSION_MAJOR == 2
  297. #  define flagSet_DB2(i, f) i |= f
  298. #else
  299. #  define flagSet_DB2(i, f)
  300. #endif
  302. #if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 5
  303. #  define flagSet(bitmask)        (flags & (bitmask))
  304. #else
  305. #  define flagSet(bitmask) ((flags & DB_OPFLAGS_MASK) == (bitmask))
  306. #endif
  308. #ifdef DBM_FILTERING
  309. #define ckFilter(arg,type,name)                                 
  310.         if (db->type) {                                         
  311.             SV * save_defsv ;                                   
  312.             /* printf("filtering %sn", name) ;*/               
  313.             if (db->filtering)                                  
  314.                 softCrash("recursion detected in %s", name) ;   
  315.             db->filtering = TRUE ;                              
  316.             save_defsv = newSVsv(DEFSV) ;                       
  317.             sv_setsv(DEFSV, arg) ;                              
  318.             PUSHMARK(sp) ;                                      
  319.             (void) perl_call_sv(db->type, G_DISCARD|G_NOARGS);  
  320.             sv_setsv(arg, DEFSV) ;                              
  321.             sv_setsv(DEFSV, save_defsv) ;                       
  322.             SvREFCNT_dec(save_defsv) ;                          
  323.             db->filtering = FALSE ;                             
  324.             /*printf("end of filtering %sn", name) ;*/         
  325.         }
  326. #else
  327. #define ckFilter(type, sv, name)
  328. #endif
  330. #define ERR_BUFF "BerkeleyDB::Error"
  332. #define ZMALLOC(to, typ) ((to = (typ *)safemalloc(sizeof(typ))), 
  333. Zero(to,1,typ))
  335. #define DBT_clear(x) Zero(&x, 1, DBT) ;
  337. #if 1
  338. #define getInnerObject(x) SvIV(*av_fetch((AV*)SvRV(x), 0, FALSE))
  339. #else
  340. #define getInnerObject(x) SvIV((SV*)SvRV(sv))
  341. #endif
  343. #define my_sv_setpvn(sv, d, s) (s ? sv_setpvn(sv, d, s) : sv_setpv(sv, "") )
  345. #define SetValue_iv(i, k) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) 
  346. i = SvIV(sv)
  347. #define SetValue_io(i, k) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) 
  348. i = IoOFP(sv_2io(sv))
  349. #define SetValue_sv(i, k) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) 
  350. i = sv
  351. #define SetValue_pv(i, k,t) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) 
  352. i = (t)SvPV(sv,PL_na)
  353. #define SetValue_pvx(i, k, t) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) 
  354. i = (t)SvPVX(sv)
  355. #define SetValue_ov(i,k,t) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) {
  356. IV tmp = getInnerObject(sv) ;
  357. i = (t) tmp ;
  358.   }
  360. #define SetValue_ovx(i,k,t) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) {
  361. HV * hv = (HV *)GetInternalObject(sv);
  362. SV ** svp = hv_fetch(hv, "db", 2, FALSE);
  363. IV tmp = SvIV(*svp);
  364. i = (t) tmp ;
  365.   }
  367. #define SetValue_ovX(i,k,t) if ((sv = readHash(hash, k)) && sv != &PL_sv_undef) {
  368. IV tmp = SvIV(GetInternalObject(sv));
  369. i = (t) tmp ;
  370.   }
  372. #define LastDBerror DB_RUNRECOVERY
  374. #define setDUALerrno(var, err)
  375. sv_setnv(var, (double)err) ;
  376. sv_setpv(var, ((err) ? db_strerror(err) : "")) ;
  377. SvNOK_on(var);
  379. #define OutputValue(arg, name)                                  
  380.         { if (RETVAL == 0) {                                    
  381.               my_sv_setpvn(arg, name.data, name.size) ;         
  382.               ckFilter(arg, filter_fetch_value,"filter_fetch_value") ;            
  383.           }                                                     
  384.         }
  386. #define OutputValue_B(arg, name)                                  
  387.         { if (RETVAL == 0) {                                    
  388. if (db->type == DB_BTREE && 
  389. flagSet(DB_GET_RECNO)){
  390.                     sv_setiv(arg, (I32)(*(I32*)name.data) - RECNO_BASE); 
  391.                 }                                               
  392.                 else {                                          
  393.                     my_sv_setpvn(arg, name.data, name.size) ;   
  394.                 }                                               
  395.                 ckFilter(arg, filter_fetch_value, "filter_fetch_value");          
  396.           }                                                     
  397.         }
  399. #define OutputKey(arg, name)                                    
  400.         { if (RETVAL == 0) 
  401.           {                                                     
  402.                 if (!db->recno_or_queue) {                     
  403.                     my_sv_setpvn(arg, name.data, name.size);    
  404.                 }                                               
  405.                 else                                            
  406.                     sv_setiv(arg, (I32)*(I32*)name.data - RECNO_BASE);   
  407.                 ckFilter(arg, filter_fetch_key, "filter_fetch_key") ;            
  408.           }                                                     
  409.         }
  411. #define OutputKey_B(arg, name)                                  
  412.         { if (RETVAL == 0) 
  413.           {                                                     
  414.                 if (db->recno_or_queue ||
  415. (db->type == DB_BTREE && 
  416.     flagSet(DB_GET_RECNO))){
  417.                     sv_setiv(arg, (I32)(*(I32*)name.data) - RECNO_BASE); 
  418.                 }                                               
  419.                 else {                                          
  420.                     my_sv_setpvn(arg, name.data, name.size);    
  421.                 }                                               
  422.                 ckFilter(arg, filter_fetch_key, "filter_fetch_key") ;            
  423.           }                                                     
  424.         }
  426. #define SetPartial(data,db) 
  427. data.flags = db->partial ;
  428. data.dlen  = db->dlen ;
  429. data.doff  = db->doff ;
  431. #define ckActive(active, type) 
  432.     {
  433. if (!active)
  434.     softCrash("%s is already closed", type) ;
  435.     }
  437. #define ckActive_Environment(a) ckActive(a, "Environment")
  438. #define ckActive_TxnMgr(a) ckActive(a, "Transaction Manager")
  439. #define ckActive_Transaction(a) ckActive(a, "Transaction")
  440. #define ckActive_Database(a)  ckActive(a, "Database")
  441. #define ckActive_Cursor(a)  ckActive(a, "Cursor")
  443. /* Internal Global Data */
  444. static db_recno_t Value ;
  445. static db_recno_t zero = 0 ;
  446. static BerkeleyDB CurrentDB ;
  447. static DBTKEY empty ;
  448. static char ErrBuff[1000] ;
  450. static char *
  451. my_strdup(const char *s)
  452. {
  453.     if (s == NULL)
  454.         return NULL ;
  456.     {
  457.         MEM_SIZE l = strlen(s);
  458.         char *s1 = (char *)safemalloc(l);
  460.         Copy(s, s1, (MEM_SIZE)l, char);
  461.         return s1;
  462.     }
  463. }
  465. #if DB_VERSION_MAJOR == 2
  466. static char *
  467. db_strerror(int err)
  468. {
  469.     if (err == 0)
  470.         return "" ;
  472.     if (err > 0)
  473.         return Strerror(err) ;
  475.     switch (err) {
  476. case DB_INCOMPLETE:
  477. return ("DB_INCOMPLETE: Sync was unable to complete");
  478. case DB_KEYEMPTY:
  479. return ("DB_KEYEMPTY: Non-existent key/data pair");
  480. case DB_KEYEXIST:
  481. return ("DB_KEYEXIST: Key/data pair already exists");
  482. case DB_LOCK_DEADLOCK:
  483. return (
  484.     "DB_LOCK_DEADLOCK: Locker killed to resolve a deadlock");
  485. case DB_LOCK_NOTGRANTED:
  486. return ("DB_LOCK_NOTGRANTED: Lock not granted");
  487. case DB_LOCK_NOTHELD:
  488. return ("DB_LOCK_NOTHELD: Lock not held by locker");
  489. case DB_NOTFOUND:
  490. return ("DB_NOTFOUND: No matching key/data pair found");
  491. case DB_RUNRECOVERY:
  492. return ("DB_RUNRECOVERY: Fatal error, run database recovery");
  493. default:
  494. return "Unknown Error" ;
  496.     }
  497. }
  498. #endif  /* DB_VERSION_MAJOR == 2 */
  500. static char *
  501. my_db_strerror(int err)
  502. {
  503.     static char buffer[1000] ;
  504.     SV * sv = perl_get_sv(ERR_BUFF, FALSE) ;
  505.     sprintf(buffer, "%d: %s", err, db_strerror(err)) ;
  506.     if (err && sv) {
  507.         strcat(buffer, ", ") ;
  508. strcat(buffer, SvPVX(sv)) ;
  509.     }
  510.     return buffer;
  511. }
  513. static void
  514. close_everything(void)
  515. {
  516.     dTHR;
  517.     Trace(("close_everythingn")) ;
  518.     /* Abort All Transactions */
  519.     {
  520. BerkeleyDB__Txn__Raw  tid ;
  521. HE * he ;
  522. I32 len ;
  523. HV * hv = perl_get_hv("BerkeleyDB::Term::Txn", TRUE);
  524. I32 ret = hv_iterinit(hv) ;
  525. int  all = 0 ;
  526. int  closed = 0 ;
  527. Trace(("BerkeleyDB::Term::close_all_txns dirty=%dn", PL_dirty)) ;
  528. while ( he = hv_iternext(hv) ) {
  529.     tid = * (BerkeleyDB__Txn__Raw *) (IV) hv_iterkey(he, &len) ;
  530.     Trace(("  Aborting Transaction [%d] in [%d] Active [%d]n", tid->txn, tid, tid->active));
  531.     if (tid->active) {
  532.         txn_abort(tid->txn);
  533. ++ closed ;
  534.     }
  535.     tid->active = FALSE ;
  536.     ++ all ;
  537. }
  538. Trace(("End of BerkeleyDB::Term::close_all_txns aborted %d of %d transactiosn",closed, all)) ;
  539.     }
  541.     /* Close All Cursors */
  542.     {
  543. BerkeleyDB__Cursor db ;
  544. HE * he ;
  545. I32 len ;
  546. HV * hv = perl_get_hv("BerkeleyDB::Term::Cursor", TRUE);
  547. I32 ret = hv_iterinit(hv) ;
  548. int  all = 0 ;
  549. int  closed = 0 ;
  550. Trace(("BerkeleyDB::Term::close_all_cursors n")) ;
  551. while ( he = hv_iternext(hv) ) {
  552.     db = * (BerkeleyDB__Cursor*) (IV) hv_iterkey(he, &len) ;
  553.     Trace(("  Closing Cursor [%d] in [%d] Active [%d]n", db->cursor, db, db->active));
  554.     if (db->active) {
  555.              ((db->cursor)->c_close)(db->cursor) ;
  556. ++ closed ;
  557.     }
  558.     db->active = FALSE ;
  559.     ++ all ;
  560. }
  561. Trace(("End of BerkeleyDB::Term::close_all_cursors closed %d of %d cursorsn",closed, all)) ;
  562.     }
  564.     /* Close All Databases */
  565.     {
  566. BerkeleyDB db ;
  567. HE * he ;
  568. I32 len ;
  569. HV * hv = perl_get_hv("BerkeleyDB::Term::Db", TRUE);
  570. I32 ret = hv_iterinit(hv) ;
  571. int  all = 0 ;
  572. int  closed = 0 ;
  573. Trace(("BerkeleyDB::Term::close_all_dbsn" )) ;
  574. while ( he = hv_iternext(hv) ) {
  575.     db = * (BerkeleyDB*) (IV) hv_iterkey(he, &len) ;
  576.     Trace(("  Closing Database [%d] in [%d] Active [%d]n", db->dbp, db, db->active));
  577.     if (db->active) {
  578.         (db->dbp->close)(db->dbp, 0) ;
  579. ++ closed ;
  580.     }
  581.     db->active = FALSE ;
  582.     ++ all ;
  583. }
  584. Trace(("End of BerkeleyDB::Term::close_all_dbs closed %d of %d dbsn",closed, all)) ;
  585.     }
  587.     /* Close All Environments */
  588.     {
  589. BerkeleyDB__Env env ;
  590. HE * he ;
  591. I32 len ;
  592. HV * hv = perl_get_hv("BerkeleyDB::Term::Env", TRUE);
  593. I32 ret = hv_iterinit(hv) ;
  594. int  all = 0 ;
  595. int  closed = 0 ;
  596. Trace(("BerkeleyDB::Term::close_all_envsn")) ;
  597. while ( he = hv_iternext(hv) ) {
  598.     env = * (BerkeleyDB__Env*) (IV) hv_iterkey(he, &len) ;
  599.     Trace(("  Closing Environment [%d] in [%d] Active [%d]n", env->Env, env, env->active));
  600.     if (env->active) {
  601. #if DB_VERSION_MAJOR == 2
  602.                 db_appexit(env->Env) ;
  603. #else
  604.         (env->Env->close)(env->Env, 0) ;
  605. #endif
  606. ++ closed ;
  607.     }
  608.     env->active = FALSE ;
  609.     ++ all ;
  610. }
  611. Trace(("End of BerkeleyDB::Term::close_all_envs closed %d of %d dbsn",closed, all)) ;
  612.     }
  614.     Trace(("end close_everythingn")) ;
  616. }
  618. static void
  619. destroyDB(BerkeleyDB db)
  620. {
  621.     dTHR;
  622.     if (! PL_dirty && db->active) {
  623.        -- db->open_cursors ;
  624. ((db->dbp)->close)(db->dbp, 0) ;
  625.     }
  626.     if (db->hash)
  627.           SvREFCNT_dec(db->hash) ;
  628.     if (db->compare)
  629.           SvREFCNT_dec(db->compare) ;
  630.     if (db->dup_compare)
  631.           SvREFCNT_dec(db->dup_compare) ;
  632.     if (db->prefix)
  633.           SvREFCNT_dec(db->prefix) ;
  634. #ifdef DBM_FILTERING
  635.     if (db->filter_fetch_key)
  636.           SvREFCNT_dec(db->filter_fetch_key) ;
  637.     if (db->filter_store_key)
  638.           SvREFCNT_dec(db->filter_store_key) ;
  639.     if (db->filter_fetch_value)
  640.           SvREFCNT_dec(db->filter_fetch_value) ;
  641.     if (db->filter_store_value)
  642.           SvREFCNT_dec(db->filter_store_value) ;
  643. #endif
  644.     hash_delete("BerkeleyDB::Term::Db", (IV)db) ;
  645.     if (db->filename)
  646.              Safefree(db->filename) ;
  647.     Safefree(db) ;
  648. }
  650. static void
  651. softCrash(const char *pat, ...)
  652. {
  653.     char buffer1 [500] ;
  654.     char buffer2 [500] ;
  655.     va_list args;
  656.     va_start(args, pat);
  658.     Trace(("softCrash: %sn", pat)) ;
  660. #define ABORT_PREFIX "BerkeleyDB Aborting: "
  662.     /* buffer = (char*) safemalloc(strlen(pat) + strlen(ABORT_PREFIX) + 1) ; */
  663.     strcpy(buffer1, ABORT_PREFIX) ;
  664.     strcat(buffer1, pat) ;
  666.     vsprintf(buffer2, buffer1, args) ;
  668.     croak(buffer2);
  670.     /* NOTREACHED */
  671.     va_end(args);
  672. }
  675. static I32
  676. GetArrayLength(BerkeleyDB db)
  677. {
  678.     DBT key ;
  679.     DBT value ;
  680.     int RETVAL = 0 ;
  681.     DBC *    cursor ;
  683.     DBT_clear(key) ;
  684.     DBT_clear(value) ;
  685. #if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
  686.     if ( ((db->dbp)->cursor)(db->dbp, db->txn, &cursor) == 0 )
  687. #else
  688.     if ( ((db->dbp)->cursor)(db->dbp, db->txn, &cursor, 0) == 0 )
  689. #endif
  690.     {
  691.         RETVAL = cursor->c_get(cursor, &key, &value, DB_LAST) ;
  692.         if (RETVAL == 0)
  693.             RETVAL = *(I32 *)key.data ;
  694.         else /* No key means empty file */
  695.             RETVAL = 0 ;
  696.         cursor->c_close(cursor) ;
  697.     }
  699.     Trace(("GetArrayLength got %dn", RETVAL)) ;
  700.     return ((I32)RETVAL) ;
  701. }
  703. #if 0
  705. #define GetRecnoKey(db, value)  _GetRecnoKey(db, value)
  707. static db_recno_t
  708. _GetRecnoKey(BerkeleyDB db, I32 value)
  709. {
  710.     Trace(("GetRecnoKey start value = %dn", value)) ;
  711.     if (db->recno_or_queue && value < 0) {
  712. /* Get the length of the array */
  713. I32 length = GetArrayLength(db) ;
  715. /* check for attempt to write before start of array */
  716. if (length + value + RECNO_BASE <= 0)
  717.     softCrash("Modification of non-creatable array value attempted, subscript %ld", (long)value) ;
  719. value = length + value + RECNO_BASE ;
  720.     }
  721.     else
  722.         ++ value ;
  724.     Trace(("GetRecnoKey end value = %dn", value)) ;
  726.     return value ;
  727. }
  729. #else /* ! 0 */
  731. #if 0
  732. #ifdef ALLOW_RECNO_OFFSET
  733. #define GetRecnoKey(db, value) _GetRecnoKey(db, value)
  735. static db_recno_t
  736. _GetRecnoKey(BerkeleyDB db, I32 value)
  737. {
  738.     if (value + RECNO_BASE < 1)
  739. softCrash("key value %d < base (%d)", (value), RECNO_BASE?0:1) ;
  740.     return value + RECNO_BASE ;
  741. }
  743. #else
  744. #endif /* ALLOW_RECNO_OFFSET */
  745. #endif /* 0 */
  747. #define GetRecnoKey(db, value) ((value) + RECNO_BASE )
  749. #endif /* 0 */
  751. static SV *
  752. GetInternalObject(SV * sv)
  753. {
  754.     SV * info = (SV*) NULL ;
  755.     SV * s ;
  756.     MAGIC * mg ;
  758.     Trace(("in GetInternalObject %dn", sv)) ;
  759.     if (sv == NULL || !SvROK(sv))
  760.         return NULL ;
  762.     s = SvRV(sv) ;
  763.     if (SvMAGICAL(s))
  764.     {
  765.         if (SvTYPE(s) == SVt_PVHV || SvTYPE(s) == SVt_PVAV)
  766.             mg = mg_find(s, 'P') ;
  767.         else
  768.             mg = mg_find(s, 'q') ;
  770.  /* all this testing is probably overkill, but till I know more
  771.     about global destruction it stays.
  772.  */
  773.         /* if (mg && mg->mg_obj && SvRV(mg->mg_obj) && SvPVX(SvRV(mg->mg_obj))) */
  774.         if (mg && mg->mg_obj && SvRV(mg->mg_obj) )
  775.             info = SvRV(mg->mg_obj) ;
  776. else
  777.     info = s ;
  778.     }
  780.     Trace(("end of GetInternalObject %dn", info)) ;
  781.     return info ;
  782. }
  784. static int
  785. btree_compare(DB_callback const DBT * key1, const DBT * key2 )
  786. {
  787.     dSP ;
  788.     void * data1, * data2 ;
  789.     int retval ;
  790.     int count ;
  792.     data1 = key1->data ;
  793.     data2 = key2->data ;
  795. #ifndef newSVpvn
  796.     /* As newSVpv will assume that the data pointer is a null terminated C
  797.        string if the size parameter is 0, make sure that data points to an
  798.        empty string if the length is 0
  799.     */
  800.     if (key1->size == 0)
  801.         data1 = "" ;
  802.     if (key2->size == 0)
  803.         data2 = "" ;
  804. #endif
  806.     ENTER ;
  807.     SAVETMPS;
  809.     PUSHMARK(SP) ;
  810.     EXTEND(SP,2) ;
  811.     PUSHs(sv_2mortal(newSVpvn(data1,key1->size)));
  812.     PUSHs(sv_2mortal(newSVpvn(data2,key2->size)));
  813.     PUTBACK ;
  815.     count = perl_call_sv(CurrentDB->compare, G_SCALAR);
  817.     SPAGAIN ;
  819.     if (count != 1)
  820.         softCrash ("in btree_compare - expected 1 return value from compare sub, got %d", count) ;
  822.     retval = POPi ;
  824.     PUTBACK ;
  825.     FREETMPS ;
  826.     LEAVE ;
  827.     return (retval) ;
  829. }
  831. static int
  832. dup_compare(DB_callback const DBT * key1, const DBT * key2 )
  833. {
  834.     dSP ;
  835.     void * data1, * data2 ;
  836.     int retval ;
  837.     int count ;
  839.     Trace(("In dup_compare n")) ;
  840.     if (!CurrentDB)
  841. softCrash("Internal Error - No CurrentDB in dup_compare") ;
  842.     if (CurrentDB->dup_compare == NULL)
  843.         softCrash("in dup_compare: no callback specified for database '%s'", CurrentDB->filename) ;
  845.     data1 = key1->data ;
  846.     data2 = key2->data ;
  848. #ifndef newSVpvn
  849.     /* As newSVpv will assume that the data pointer is a null terminated C
  850.        string if the size parameter is 0, make sure that data points to an
  851.        empty string if the length is 0
  852.     */
  853.     if (key1->size == 0)
  854.         data1 = "" ;
  855.     if (key2->size == 0)
  856.         data2 = "" ;
  857. #endif
  859.     ENTER ;
  860.     SAVETMPS;
  862.     PUSHMARK(SP) ;
  863.     EXTEND(SP,2) ;
  864.     PUSHs(sv_2mortal(newSVpvn(data1,key1->size)));
  865.     PUSHs(sv_2mortal(newSVpvn(data2,key2->size)));
  866.     PUTBACK ;
  868.     count = perl_call_sv(CurrentDB->dup_compare, G_SCALAR);
  870.     SPAGAIN ;
  872.     if (count != 1)
  873.         softCrash ("dup_compare: expected 1 return value from compare sub, got %d", count) ;
  875.     retval = POPi ;
  877.     PUTBACK ;
  878.     FREETMPS ;
  879.     LEAVE ;
  880.     return (retval) ;
  882. }
  884. static size_t
  885. btree_prefix(DB_callback const DBT * key1, const DBT * key2 )
  886. {
  887.     dSP ;
  888.     void * data1, * data2 ;
  889.     int retval ;
  890.     int count ;
  892.     data1 = key1->data ;
  893.     data2 = key2->data ;
  895. #ifndef newSVpvn
  896.     /* As newSVpv will assume that the data pointer is a null terminated C
  897.        string if the size parameter is 0, make sure that data points to an
  898.        empty string if the length is 0
  899.     */
  900.     if (key1->size == 0)
  901.         data1 = "" ;
  902.     if (key2->size == 0)
  903.         data2 = "" ;
  904. #endif
  906.     ENTER ;
  907.     SAVETMPS;
  909.     PUSHMARK(SP) ;
  910.     EXTEND(SP,2) ;
  911.     PUSHs(sv_2mortal(newSVpvn(data1,key1->size)));
  912.     PUSHs(sv_2mortal(newSVpvn(data2,key2->size)));
  913.     PUTBACK ;
  915.     count = perl_call_sv(CurrentDB->prefix, G_SCALAR);
  917.     SPAGAIN ;
  919.     if (count != 1)
  920.         softCrash ("btree_prefix: expected 1 return value from prefix sub, got %d", count) ;
  922.     retval = POPi ;
  924.     PUTBACK ;
  925.     FREETMPS ;
  926.     LEAVE ;
  928.     return (retval) ;
  929. }
  931. static u_int32_t
  932. hash_cb(DB_callback const void * data, u_int32_t size)
  933. {
  934.     dSP ;
  935.     int retval ;
  936.     int count ;
  938. #ifndef newSVpvn
  939.     if (size == 0)
  940.         data = "" ;
  941. #endif
  943.     ENTER ;
  944.     SAVETMPS;
  946.     PUSHMARK(SP) ;
  948.     XPUSHs(sv_2mortal(newSVpvn((char*)data,size)));
  949.     PUTBACK ;
  951.     count = perl_call_sv(CurrentDB->hash, G_SCALAR);
  953.     SPAGAIN ;
  955.     if (count != 1)
  956.         softCrash ("hash_cb: expected 1 return value from hash sub, got %d", count) ;
  958.     retval = POPi ;
  960.     PUTBACK ;
  961.     FREETMPS ;
  962.     LEAVE ;
  964.     return (retval) ;
  965. }
  967. static void
  968. db_errcall_cb(const char * db_errpfx, char * buffer)
  969. {
  970. #if 0
  972.     if (db_errpfx == NULL)
  973. db_errpfx = "" ;
  974.     if (buffer == NULL )
  975. buffer = "" ;
  976.     ErrBuff[0] = '';
  977.     if (strlen(db_errpfx) + strlen(buffer) + 3 <= 1000) {
  978. if (*db_errpfx != '') {
  979.     strcat(ErrBuff, db_errpfx) ;
  980.     strcat(ErrBuff, ": ") ;
  981. }
  982. strcat(ErrBuff, buffer) ;
  983.     }
  985. #endif
  987.     SV * sv = perl_get_sv(ERR_BUFF, FALSE) ;
  988.     if (sv) {
  989.         if (db_errpfx)
  990.     sv_setpvf(sv, "%s: %s", db_errpfx, buffer) ;
  991.         else
  992.             sv_setpv(sv, buffer) ;
  993.     }
  994. }
  996. static SV *
  997. readHash(HV * hash, char * key)
  998. {
  999.     SV **       svp;
  1000.     svp = hv_fetch(hash, key, strlen(key), FALSE);
  1001.     if (svp && SvOK(*svp))
  1002.         return *svp ;
  1003.     return NULL ;
  1004. }
  1006. static void
  1007. hash_delete(char * hash, IV key)
  1008. {
  1009.     HV * hv = perl_get_hv(hash, TRUE);
  1010.     (void) hv_delete(hv, (char*)&key, sizeof(key), G_DISCARD);
  1011. }
  1013. static void
  1014. hash_store_iv(char * hash, IV key, IV value)
  1015. {
  1016.     HV * hv = perl_get_hv(hash, TRUE);
  1017.     SV ** ret = hv_store(hv, (char*)&key, sizeof(key), newSViv(value), 0);
  1018.     /* printf("hv_store returned %dn", ret) ; */
  1019. }
  1021. static void
  1022. hv_store_iv(HV * hash, char * key, IV value)
  1023. {
  1024.     hv_store(hash, key, strlen(key), newSViv(value), 0);
  1025. }
  1027. static BerkeleyDB
  1028. my_db_open(
  1029. BerkeleyDB db ,
  1030. SV *  ref,
  1031. SV * ref_dbenv ,
  1032. BerkeleyDB__Env dbenv ,
  1033. const char * file,
  1034. const char * subname,
  1035. DBTYPE type,
  1036. int flags,
  1037. int mode,
  1038. DB_INFO *  info
  1039. )
  1040. {
  1041.     DB_ENV * env    = NULL ;
  1042.     BerkeleyDB  RETVAL = NULL ;
  1043.     DB * dbp ;
  1044.     int Status ;
  1046.     Trace(("_db_open(dbenv[%lu] ref_dbenv [%lu] file[%s] subname [%s] type[%d] flags[%d] mode[%d]n",
  1047. dbenv, ref_dbenv, file, subname, type, flags, mode)) ;
  1049.     CurrentDB = db ;
  1050.     if (dbenv)
  1051. env = dbenv->Env ;
  1053. #if DB_VERSION_MAJOR == 2
  1054.     if (subname)
  1055.         softCrash("Subname needs Berkeley DB 3 or better") ;
  1056. #endif
  1058. #if DB_VERSION_MAJOR > 2
  1059.     Status = db_create(&dbp, env, 0) ;
  1060.     Trace(("db_create returned %sn", my_db_strerror(Status))) ;
  1061.     if (Status)
  1062.         return RETVAL ;
  1064.     if (info->re_source) {
  1065.         Status = dbp->set_re_source(dbp, info->re_source) ;
  1066. Trace(("set_re_source [%s] returned %sn",
  1067. info->re_source, my_db_strerror(Status)));
  1068.         if (Status)
  1069.             return RETVAL ;
  1070.     }
  1072.     if (info->db_cachesize) {
  1073.         Status = dbp->set_cachesize(dbp, 0, info->db_cachesize, 0) ;
  1074. Trace(("set_cachesize [%d] returned %sn",
  1075. info->db_cachesize, my_db_strerror(Status)));
  1076.         if (Status)
  1077.             return RETVAL ;
  1078.     }
  1080.     if (info->db_lorder) {
  1081.         Status = dbp->set_lorder(dbp, info->db_lorder) ;
  1082. Trace(("set_lorder [%d] returned %sn",
  1083. info->db_lorder, my_db_strerror(Status)));
  1084.         if (Status)
  1085.             return RETVAL ;
  1086.     }
  1088.     if (info->db_pagesize) {
  1089.         Status = dbp->set_pagesize(dbp, info->db_pagesize) ;
  1090. Trace(("set_pagesize [%d] returned %sn",
  1091. info->db_pagesize, my_db_strerror(Status)));
  1092.         if (Status)
  1093.             return RETVAL ;
  1094.     }
  1096.     if (info->h_ffactor) {
  1097.         Status = dbp->set_h_ffactor(dbp, info->h_ffactor) ;
  1098. Trace(("set_h_ffactor [%d] returned %sn",
  1099. info->h_ffactor, my_db_strerror(Status)));
  1100.         if (Status)
  1101.             return RETVAL ;
  1102.     }
  1104.     if (info->h_nelem) {
  1105.         Status = dbp->set_h_nelem(dbp, info->h_nelem) ;
  1106. Trace(("set_h_nelem [%d] returned %sn",
  1107. info->h_nelem, my_db_strerror(Status)));
  1108.         if (Status)
  1109.             return RETVAL ;
  1110.     }
  1112.     if (info->bt_minkey) {
  1113.         Status = dbp->set_bt_minkey(dbp, info->bt_minkey) ;
  1114. Trace(("set_bt_minkey [%d] returned %sn",
  1115. info->bt_minkey, my_db_strerror(Status)));
  1116.         if (Status)
  1117.             return RETVAL ;
  1118.     }
  1120.     if (info->bt_compare) {
  1121.         Status = dbp->set_bt_compare(dbp, info->bt_compare) ;
  1122. Trace(("set_bt_compare [%d] returned %sn",
  1123. info->bt_compare, my_db_strerror(Status)));
  1124.         if (Status)
  1125.             return RETVAL ;
  1126.     }
  1128.     if (info->h_hash) {
  1129.         Status = dbp->set_h_hash(dbp, info->h_hash) ;
  1130. Trace(("set_h_hash [%d] returned %sn",
  1131. info->h_hash, my_db_strerror(Status)));
  1132.         if (Status)
  1133.             return RETVAL ;
  1134.     }
  1136.     if (info->dup_compare) {
  1137.         Status = dbp->set_dup_compare(dbp, info->dup_compare) ;
  1138. Trace(("set_dup_compare [%d] returned %sn",
  1139. info->dup_compare, my_db_strerror(Status)));
  1140.         if (Status)
  1141.             return RETVAL ;
  1142.     }
  1144.     if (info->bt_prefix) {
  1145.         Status = dbp->set_bt_prefix(dbp, info->bt_prefix) ;
  1146. Trace(("set_bt_prefix [%d] returned %sn",
  1147. info->bt_prefix, my_db_strerror(Status)));
  1148.         if (Status)
  1149.             return RETVAL ;
  1150.     }
  1152.     if (info->re_len) {
  1153.         Status = dbp->set_re_len(dbp, info->re_len) ;
  1154. Trace(("set_re_len [%d] returned %sn",
  1155. info->re_len, my_db_strerror(Status)));
  1156.         if (Status)
  1157.             return RETVAL ;
  1158.     }
  1160.     if (info->re_delim) {
  1161.         Status = dbp->set_re_delim(dbp, info->re_delim) ;
  1162. Trace(("set_re_delim [%d] returned %sn",
  1163. info->re_delim, my_db_strerror(Status)));
  1164.         if (Status)
  1165.             return RETVAL ;
  1166.     }
  1168.     if (info->re_pad) {
  1169.         Status = dbp->set_re_pad(dbp, info->re_pad) ;
  1170. Trace(("set_re_pad [%d] returned %sn",
  1171. info->re_pad, my_db_strerror(Status)));
  1172.         if (Status)
  1173.             return RETVAL ;
  1174.     }
  1176.     if (info->flags) {
  1177.         Status = dbp->set_flags(dbp, info->flags) ;
  1178. Trace(("set_flags [%d] returned %sn",
  1179. info->flags, my_db_strerror(Status)));
  1180.         if (Status)
  1181.             return RETVAL ;
  1182.     }
  1184.     if (info->q_extentsize) {
  1185. #ifdef AT_LEAST_DB_3_2
  1186.         Status = dbp->set_q_extentsize(dbp, info->q_extentsize) ;
  1187. Trace(("set_flags [%d] returned %sn",
  1188. info->flags, my_db_strerror(Status)));
  1189.         if (Status)
  1190.             return RETVAL ;
  1191. #else
  1192.         softCrash("-ExtentSize needs at least Berkeley DB 3.2.x") ;
  1193. #endif
  1194.     }
  1196.     if ((Status = (dbp->open)(dbp, file, subname, type, flags, mode)) == 0) {
  1197. #else /* DB_VERSION_MAJOR == 2 */
  1198.     if ((Status = db_open(file, type, flags, mode, env, info, &dbp)) == 0) {
  1199. #endif /* DB_VERSION_MAJOR == 2 */
  1201. Trace(("db_openedn"));
  1202. RETVAL = db ;
  1203. RETVAL->dbp  = dbp ;
  1204. #if DB_VERSION_MAJOR == 2
  1205.      RETVAL->type = dbp->type ;
  1206. #else /* DB_VERSION_MAJOR > 2 */
  1207.      RETVAL->type = dbp->get_type(dbp) ;
  1208. #endif /* DB_VERSION_MAJOR > 2 */
  1209.      RETVAL->recno_or_queue = (RETVAL->type == DB_RECNO ||
  1210.                           RETVAL->type == DB_QUEUE) ;
  1211. RETVAL->filename = my_strdup(file) ;
  1212. RETVAL->Status = Status ;
  1213. RETVAL->active = TRUE ;
  1214. hash_store_iv("BerkeleyDB::Term::Db", (IV)RETVAL, 1) ;
  1215. Trace(("  storing %d %d in BerkeleyDB::Term::Dbn", RETVAL, dbp)) ;
  1216. if (dbenv) {
  1217.     RETVAL->parent_env = dbenv ;
  1218.     dbenv->Status = Status ;
  1219.     ++ dbenv->open_dbs ;
  1220. }
  1221.     }
  1222.     else {
  1223. #if DB_VERSION_MAJOR > 2
  1224. (dbp->close)(dbp, 0) ;
  1225. #endif
  1226. destroyDB(db) ;
  1227.         Trace(("db open returned %sn", my_db_strerror(Status))) ;
  1228.     }
  1230.     return RETVAL ;
  1231. }
  1233. static double
  1234. constant(char * name, int arg)
  1235. {
  1236.     errno = 0;
  1237.     switch (*name) {
  1238.     case 'A':
  1239. break;
  1240.     case 'B':
  1241. break;
  1242.     case 'C':
  1243. break;
  1244.     case 'D':
  1245.         if (strEQ(name, "DB_AFTER"))
  1246. #ifdef DB_AFTER
  1247.             return DB_AFTER;
  1248. #else
  1249.             goto not_there;
  1250. #endif
  1251.         if (strEQ(name, "DB_APPEND"))
  1252. #ifdef DB_APPEND
  1253.             return DB_APPEND;
  1254. #else
  1255.             goto not_there;
  1256. #endif
  1257.         if (strEQ(name, "DB_ARCH_ABS"))
  1258. #ifdef DB_ARCH_ABS
  1259.             return DB_ARCH_ABS;
  1260. #else
  1261.             goto not_there;
  1262. #endif
  1263.         if (strEQ(name, "DB_ARCH_DATA"))
  1264. #ifdef DB_ARCH_DATA
  1265.             return DB_ARCH_DATA;
  1266. #else
  1267.             goto not_there;
  1268. #endif
  1269.         if (strEQ(name, "DB_ARCH_LOG"))
  1270. #ifdef DB_ARCH_LOG
  1271.             return DB_ARCH_LOG;
  1272. #else
  1273.             goto not_there;
  1274. #endif
  1275.         if (strEQ(name, "DB_BEFORE"))
  1276. #ifdef DB_BEFORE
  1277.             return DB_BEFORE;
  1278. #else
  1279.             goto not_there;
  1280. #endif
  1281.         if (strEQ(name, "DB_BTREE"))
  1282.             return DB_BTREE;
  1283.         if (strEQ(name, "DB_BTREEMAGIC"))
  1284. #ifdef DB_BTREEMAGIC
  1285.             return DB_BTREEMAGIC;
  1286. #else
  1287.             goto not_there;
  1288. #endif
  1289.         if (strEQ(name, "DB_BTREEOLDVER"))
  1290. #ifdef DB_BTREEOLDVER
  1291.             return DB_BTREEOLDVER;
  1292. #else
  1293.             goto not_there;
  1294. #endif
  1295.         if (strEQ(name, "DB_BTREEVERSION"))
  1296. #ifdef DB_BTREEVERSION
  1297.             return DB_BTREEVERSION;
  1298. #else
  1299.             goto not_there;
  1300. #endif
  1301.         if (strEQ(name, "DB_CHECKPOINT"))
  1302. #ifdef DB_CHECKPOINT
  1303.             return DB_CHECKPOINT;
  1304. #else
  1305.             goto not_there;
  1306. #endif
  1307.         if (strEQ(name, "DB_CONSUME"))
  1308. #ifdef DB_CONSUME
  1309.             return DB_CONSUME;
  1310. #else
  1311.             goto not_there;
  1312. #endif
  1313.         if (strEQ(name, "DB_CREATE"))
  1314. #ifdef DB_CREATE
  1315.             return DB_CREATE;
  1316. #else
  1317.             goto not_there;
  1318. #endif
  1319.         if (strEQ(name, "DB_CURLSN"))
  1320. #ifdef DB_CURLSN
  1321.             return DB_CURLSN;
  1322. #else
  1323.             goto not_there;
  1324. #endif
  1325.         if (strEQ(name, "DB_CURRENT"))
  1326. #ifdef DB_CURRENT
  1327.             return DB_CURRENT;
  1328. #else
  1329.             goto not_there;
  1330. #endif
  1331.         if (strEQ(name, "DB_DBT_MALLOC"))
  1332. #ifdef DB_DBT_MALLOC
  1333.             return DB_DBT_MALLOC;
  1334. #else
  1335.             goto not_there;
  1336. #endif
  1337.         if (strEQ(name, "DB_DBT_PARTIAL"))
  1338. #ifdef DB_DBT_PARTIAL
  1339.             return DB_DBT_PARTIAL;
  1340. #else
  1341.             goto not_there;
  1342. #endif
  1343.         if (strEQ(name, "DB_DBT_USERMEM"))
  1344. #ifdef DB_DBT_USERMEM
  1345.             return DB_DBT_USERMEM;
  1346. #else
  1347.             goto not_there;
  1348. #endif
  1349.         if (strEQ(name, "DB_DELETED"))
  1350. #ifdef DB_DELETED
  1351.             return DB_DELETED;
  1352. #else
  1353.             goto not_there;
  1354. #endif
  1355.         if (strEQ(name, "DB_DELIMITER"))
  1356. #ifdef DB_DELIMITER
  1357.             return DB_DELIMITER;
  1358. #else
  1359.             goto not_there;
  1360. #endif
  1361.         if (strEQ(name, "DB_DUP"))
  1362. #ifdef DB_DUP
  1363.             return DB_DUP;
  1364. #else
  1365.             goto not_there;
  1366. #endif
  1367.         if (strEQ(name, "DB_DUPSORT"))
  1368. #ifdef DB_DUPSORT
  1369.             return DB_DUPSORT;
  1370. #else
  1371.             goto not_there;
  1372. #endif
  1373.         if (strEQ(name, "DB_ENV_APPINIT"))
  1374. #ifdef DB_ENV_APPINIT
  1375.             return DB_ENV_APPINIT;
  1376. #else
  1377.             goto not_there;
  1378. #endif
  1379.         if (strEQ(name, "DB_ENV_STANDALONE"))
  1380. #ifdef DB_ENV_STANDALONE
  1381.             return DB_ENV_STANDALONE;
  1382. #else
  1383.             goto not_there;
  1384. #endif
  1385.         if (strEQ(name, "DB_ENV_THREAD"))
  1386. #ifdef DB_ENV_THREAD
  1387.             return DB_ENV_THREAD;
  1388. #else
  1389.             goto not_there;
  1390. #endif
  1391.         if (strEQ(name, "DB_EXCL"))
  1392. #ifdef DB_EXCL
  1393.             return DB_EXCL;
  1394. #else
  1395.             goto not_there;
  1396. #endif
  1397.         if (strEQ(name, "DB_FILE_ID_LEN"))
  1398. #ifdef DB_FILE_ID_LEN
  1399.             return DB_FILE_ID_LEN;
  1400. #else
  1401.             goto not_there;
  1402. #endif
  1403.         if (strEQ(name, "DB_FIRST"))
  1404. #ifdef DB_FIRST
  1405.             return DB_FIRST;
  1406. #else
  1407.             goto not_there;
  1408. #endif
  1409.         if (strEQ(name, "DB_FIXEDLEN"))
  1410. #ifdef DB_FIXEDLEN
  1411.             return DB_FIXEDLEN;
  1412. #else
  1413.             goto not_there;
  1414. #endif
  1415.         if (strEQ(name, "DB_FLUSH"))
  1416. #ifdef DB_FLUSH
  1417.             return DB_FLUSH;
  1418. #else
  1419.             goto not_there;
  1420. #endif
  1421.         if (strEQ(name, "DB_FORCE"))
  1422. #ifdef DB_FORCE
  1423.             return DB_FORCE;
  1424. #else
  1425.             goto not_there;
  1426. #endif
  1427.         if (strEQ(name, "DB_GET_BOTH"))
  1428. #ifdef DB_GET_BOTH
  1429.             return DB_GET_BOTH;
  1430. #else
  1431.             goto not_there;
  1432. #endif
  1433.         if (strEQ(name, "DB_GET_RECNO"))
  1434. #ifdef DB_GET_RECNO
  1435.             return DB_GET_RECNO;
  1436. #else
  1437.             goto not_there;
  1438. #endif
  1439.         if (strEQ(name, "DB_HASH"))
  1440.             return DB_HASH;
  1441.         if (strEQ(name, "DB_HASHMAGIC"))
  1442. #ifdef DB_HASHMAGIC
  1443.             return DB_HASHMAGIC;
  1444. #else
  1445.             goto not_there;
  1446. #endif
  1447.         if (strEQ(name, "DB_HASHOLDVER"))
  1448. #ifdef DB_HASHOLDVER
  1449.             return DB_HASHOLDVER;
  1450. #else
  1451.             goto not_there;
  1452. #endif
  1453.         if (strEQ(name, "DB_HASHVERSION"))
  1454. #ifdef DB_HASHVERSION
  1455.             return DB_HASHVERSION;
  1456. #else
  1457.             goto not_there;
  1458. #endif
  1459.         if (strEQ(name, "DB_INCOMPLETE"))
  1460. #ifdef DB_INCOMPLETE
  1461.             return DB_INCOMPLETE;
  1462. #else
  1463.             goto not_there;
  1464. #endif
  1465.         if (strEQ(name, "DB_INIT_CDB"))
  1466. #ifdef DB_INIT_CDB
  1467.             return DB_INIT_CDB;
  1468. #else
  1469.             goto not_there;
  1470. #endif
  1471.         if (strEQ(name, "DB_INIT_LOCK"))
  1472. #ifdef DB_INIT_LOCK
  1473.             return DB_INIT_LOCK;
  1474. #else
  1475.             goto not_there;
  1476. #endif
  1477.         if (strEQ(name, "DB_INIT_LOG"))
  1478. #ifdef DB_INIT_LOG
  1479.             return DB_INIT_LOG;
  1480. #else
  1481.             goto not_there;
  1482. #endif
  1483.         if (strEQ(name, "DB_INIT_MPOOL"))
  1484. #ifdef DB_INIT_MPOOL
  1485.             return DB_INIT_MPOOL;
  1486. #else
  1487.             goto not_there;
  1488. #endif
  1489.         if (strEQ(name, "DB_INIT_TXN"))
  1490. #ifdef DB_INIT_TXN
  1491.             return DB_INIT_TXN;
  1492. #else
  1493.             goto not_there;
  1494. #endif
  1495.         if (strEQ(name, "DB_JOIN_ITEM"))
  1496. #ifdef DB_JOIN_ITEM
  1497.             return DB_JOIN_ITEM;
  1498. #else
  1499.             goto not_there;
  1500. #endif
  1501.         if (strEQ(name, "DB_KEYEMPTY"))
  1502. #ifdef DB_KEYEMPTY
  1503.             return DB_KEYEMPTY;
  1504. #else
  1505.             goto not_there;
  1506. #endif
  1507.         if (strEQ(name, "DB_KEYEXIST"))
  1508. #ifdef DB_KEYEXIST
  1509.             return DB_KEYEXIST;
  1510. #else
  1511.             goto not_there;
  1512. #endif
  1513.         if (strEQ(name, "DB_KEYFIRST"))
  1514. #ifdef DB_KEYFIRST
  1515.             return DB_KEYFIRST;
  1516. #else
  1517.             goto not_there;
  1518. #endif
  1519.         if (strEQ(name, "DB_KEYLAST"))
  1520. #ifdef DB_KEYLAST
  1521.             return DB_KEYLAST;
  1522. #else
  1523.             goto not_there;
  1524. #endif
  1525.         if (strEQ(name, "DB_LAST"))
  1526. #ifdef DB_LAST
  1527.             return DB_LAST;
  1528. #else
  1529.             goto not_there;
  1530. #endif
  1531.         if (strEQ(name, "DB_LOCKMAGIC"))
  1532. #ifdef DB_LOCKMAGIC
  1533.             return DB_LOCKMAGIC;
  1534. #else
  1535.             goto not_there;
  1536. #endif
  1537.         if (strEQ(name, "DB_LOCKVERSION"))
  1538. #ifdef DB_LOCKVERSION
  1539.             return DB_LOCKVERSION;
  1540. #else
  1541.             goto not_there;
  1542. #endif
  1543.         if (strEQ(name, "DB_LOCK_CONFLICT"))
  1544. #ifdef DB_LOCK_CONFLICT
  1545.             return DB_LOCK_CONFLICT;
  1546. #else
  1547.             goto not_there;
  1548. #endif
  1549.         if (strEQ(name, "DB_LOCK_DEADLOCK"))
  1550. #ifdef DB_LOCK_DEADLOCK
  1551.             return DB_LOCK_DEADLOCK;
  1552. #else
  1553.             goto not_there;
  1554. #endif
  1555.         if (strEQ(name, "DB_LOCK_DEFAULT"))
  1556. #ifdef DB_LOCK_DEFAULT
  1557.             return DB_LOCK_DEFAULT;
  1558. #else
  1559.             goto not_there;
  1560. #endif
  1561.         if (strEQ(name, "DB_LOCK_GET"))
  1562.             return DB_LOCK_GET;
  1563.         if (strEQ(name, "DB_LOCK_NORUN"))
  1564. #ifdef DB_LOCK_NORUN
  1565.             return DB_LOCK_NORUN;
  1566. #else
  1567.             goto not_there;
  1568. #endif
  1569.         if (strEQ(name, "DB_LOCK_NOTGRANTED"))
  1570. #ifdef DB_LOCK_NOTGRANTED
  1571.             return DB_LOCK_NOTGRANTED;
  1572. #else
  1573.             goto not_there;
  1574. #endif
  1575.         if (strEQ(name, "DB_LOCK_NOTHELD"))
  1576. #ifdef DB_LOCK_NOTHELD
  1577.             return DB_LOCK_NOTHELD;
  1578. #else
  1579.             goto not_there;
  1580. #endif
  1581.         if (strEQ(name, "DB_LOCK_NOWAIT"))
  1582. #ifdef DB_LOCK_NOWAIT
  1583.             return DB_LOCK_NOWAIT;
  1584. #else
  1585.             goto not_there;
  1586. #endif
  1587.         if (strEQ(name, "DB_LOCK_OLDEST"))
  1588. #ifdef DB_LOCK_OLDEST
  1589.             return DB_LOCK_OLDEST;
  1590. #else
  1591.             goto not_there;
  1592. #endif
  1593.         if (strEQ(name, "DB_LOCK_RANDOM"))
  1594. #ifdef DB_LOCK_RANDOM
  1595.             return DB_LOCK_RANDOM;
  1596. #else
  1597.             goto not_there;
  1598. #endif
  1599.         if (strEQ(name, "DB_LOCK_RIW_N"))
  1600. #ifdef DB_LOCK_RIW_N
  1601.             return DB_LOCK_RIW_N;
  1602. #else
  1603.             goto not_there;
  1604. #endif
  1605.         if (strEQ(name, "DB_LOCK_RW_N"))
  1606. #ifdef DB_LOCK_RW_N
  1607.             return DB_LOCK_RW_N;
  1608. #else
  1609.             goto not_there;
  1610. #endif
  1611.         if (strEQ(name, "DB_LOCK_YOUNGEST"))
  1612. #ifdef DB_LOCK_YOUNGEST
  1613.             return DB_LOCK_YOUNGEST;
  1614. #else
  1615.             goto not_there;
  1616. #endif
  1617.         if (strEQ(name, "DB_LOGMAGIC"))
  1618. #ifdef DB_LOGMAGIC
  1619.             return DB_LOGMAGIC;
  1620. #else
  1621.             goto not_there;
  1622. #endif
  1623.         if (strEQ(name, "DB_LOGOLDVER"))
  1624. #ifdef DB_LOGOLDVER
  1625.             return DB_LOGOLDVER;
  1626. #else
  1627.             goto not_there;
  1628. #endif
  1629.         if (strEQ(name, "DB_MAX_PAGES"))
  1630. #ifdef DB_MAX_PAGES
  1631.             return DB_MAX_PAGES;
  1632. #else
  1633.             goto not_there;
  1634. #endif
  1635.         if (strEQ(name, "DB_MAX_RECORDS"))
  1636. #ifdef DB_MAX_RECORDS
  1637.             return DB_MAX_RECORDS;
  1638. #else
  1639.             goto not_there;
  1640. #endif
  1641.         if (strEQ(name, "DB_MPOOL_CLEAN"))
  1642. #ifdef DB_MPOOL_CLEAN
  1643.             return DB_MPOOL_CLEAN;
  1644. #else
  1645.             goto not_there;
  1646. #endif
  1647.         if (strEQ(name, "DB_MPOOL_CREATE"))
  1648. #ifdef DB_MPOOL_CREATE
  1649.             return DB_MPOOL_CREATE;
  1650. #else
  1651.             goto not_there;
  1652. #endif
  1653.         if (strEQ(name, "DB_MPOOL_DIRTY"))
  1654. #ifdef DB_MPOOL_DIRTY
  1655.             return DB_MPOOL_DIRTY;
  1656. #else
  1657.             goto not_there;
  1658. #endif
  1659.         if (strEQ(name, "DB_MPOOL_DISCARD"))
  1660. #ifdef DB_MPOOL_DISCARD
  1661.             return DB_MPOOL_DISCARD;
  1662. #else
  1663.             goto not_there;
  1664. #endif
  1665.         if (strEQ(name, "DB_MPOOL_LAST"))
  1666. #ifdef DB_MPOOL_LAST
  1667.             return DB_MPOOL_LAST;
  1668. #else
  1669.             goto not_there;
  1670. #endif
  1671.         if (strEQ(name, "DB_MPOOL_NEW"))
  1672. #ifdef DB_MPOOL_NEW
  1673.             return DB_MPOOL_NEW;
  1674. #else
  1675.             goto not_there;
  1676. #endif
  1677.         if (strEQ(name, "DB_MPOOL_PRIVATE"))
  1678. #ifdef DB_MPOOL_PRIVATE
  1679.             return DB_MPOOL_PRIVATE;
  1680. #else
  1681.             goto not_there;
  1682. #endif
  1683.         if (strEQ(name, "DB_MUTEXDEBUG"))
  1684. #ifdef DB_MUTEXDEBUG
  1685.             return DB_MUTEXDEBUG;
  1686. #else
  1687.             goto not_there;
  1688. #endif
  1689.         if (strEQ(name, "DB_MUTEXLOCKS"))
  1690. #ifdef DB_MUTEXLOCKS
  1691.             return DB_MUTEXLOCKS;
  1692. #else
  1693.             goto not_there;
  1694. #endif
  1695.         if (strEQ(name, "DB_NEEDSPLIT"))
  1696. #ifdef DB_NEEDSPLIT
  1697.             return DB_NEEDSPLIT;
  1698. #else
  1699.             goto not_there;
  1700. #endif
  1701.         if (strEQ(name, "DB_NEXT"))
  1702. #ifdef DB_NEXT
  1703.             return DB_NEXT;
  1704. #else
  1705.             goto not_there;
  1706. #endif
  1707.         if (strEQ(name, "DB_NEXT_DUP"))
  1708. #ifdef DB_NEXT_DUP
  1709.             return DB_NEXT_DUP;
  1710. #else
  1711.             goto not_there;
  1712. #endif
  1713.         if (strEQ(name, "DB_NOMMAP"))
  1714. #ifdef DB_NOMMAP
  1715.             return DB_NOMMAP;
  1716. #else
  1717.             goto not_there;
  1718. #endif
  1719.         if (strEQ(name, "DB_NOOVERWRITE"))
  1720. #ifdef DB_NOOVERWRITE
  1721.             return DB_NOOVERWRITE;
  1722. #else
  1723.             goto not_there;
  1724. #endif
  1725.         if (strEQ(name, "DB_NOSYNC"))
  1726. #ifdef DB_NOSYNC
  1727.             return DB_NOSYNC;
  1728. #else
  1729.             goto not_there;
  1730. #endif
  1731.         if (strEQ(name, "DB_NOTFOUND"))
  1732. #ifdef DB_NOTFOUND
  1733.             return DB_NOTFOUND;
  1734. #else
  1735.             goto not_there;
  1736. #endif
  1737.         if (strEQ(name, "DB_PAD"))
  1738. #ifdef DB_PAD
  1739.             return DB_PAD;
  1740. #else
  1741.             goto not_there;
  1742. #endif
  1743.         if (strEQ(name, "DB_PAGEYIELD"))
  1744. #ifdef DB_PAGEYIELD
  1745.             return DB_PAGEYIELD;
  1746. #else
  1747.             goto not_there;
  1748. #endif
  1749.         if (strEQ(name, "DB_POSITION"))
  1750. #ifdef DB_POSITION
  1751.             return DB_POSITION;
  1752. #else
  1753.             goto not_there;
  1754. #endif
  1755.         if (strEQ(name, "DB_PREV"))
  1756. #ifdef DB_PREV
  1757.             return DB_PREV;
  1758. #else
  1759.             goto not_there;
  1760. #endif
  1761.         if (strEQ(name, "DB_PRIVATE"))
  1762. #ifdef DB_PRIVATE
  1763.             return DB_PRIVATE;
  1764. #else
  1765.             goto not_there;
  1766. #endif
  1767.         if (strEQ(name, "DB_QUEUE"))
  1768.             return DB_QUEUE;
  1769.         if (strEQ(name, "DB_RDONLY"))
  1770. #ifdef DB_RDONLY
  1771.             return DB_RDONLY;
  1772. #else
  1773.             goto not_there;
  1774. #endif
  1775.         if (strEQ(name, "DB_RECNO"))
  1776.             return DB_RECNO;
  1777.         if (strEQ(name, "DB_RECNUM"))
  1778. #ifdef DB_RECNUM
  1779.             return DB_RECNUM;
  1780. #else
  1781.             goto not_there;
  1782. #endif
  1783.         if (strEQ(name, "DB_RECORDCOUNT"))
  1784. #ifdef DB_RECORDCOUNT
  1785.             return DB_RECORDCOUNT;
  1786. #else
  1787.             goto not_there;
  1788. #endif
  1789.         if (strEQ(name, "DB_RECOVER"))
  1790. #ifdef DB_RECOVER
  1791.             return DB_RECOVER;
  1792. #else
  1793.             goto not_there;
  1794. #endif
  1795.         if (strEQ(name, "DB_RECOVER_FATAL"))
  1796. #ifdef DB_RECOVER_FATAL
  1797.             return DB_RECOVER_FATAL;
  1798. #else
  1799.             goto not_there;
  1800. #endif
  1801.         if (strEQ(name, "DB_REGISTERED"))
  1802. #ifdef DB_REGISTERED
  1803.             return DB_REGISTERED;
  1804. #else
  1805.             goto not_there;
  1806. #endif
  1807.         if (strEQ(name, "DB_RENUMBER"))
  1808. #ifdef DB_RENUMBER
  1809.             return DB_RENUMBER;
  1810. #else
  1811.             goto not_there;
  1812. #endif
  1813.         if (strEQ(name, "DB_RMW"))
  1814. #ifdef DB_RMW
  1815.             return DB_RMW;
  1816. #else
  1817.             goto not_there;
  1818. #endif
  1819.         if (strEQ(name, "DB_RUNRECOVERY"))
  1820. #ifdef DB_RUNRECOVERY
  1821.             return DB_RUNRECOVERY;
  1822. #else
  1823.             goto not_there;
  1824. #endif
  1825.         if (strEQ(name, "DB_SEQUENTIAL"))
  1826. #ifdef DB_SEQUENTIAL
  1827.             return DB_SEQUENTIAL;
  1828. #else
  1829.             goto not_there;
  1830. #endif
  1831.         if (strEQ(name, "DB_SET"))
  1832. #ifdef DB_SET
  1833.             return DB_SET;
  1834. #else
  1835.             goto not_there;
  1836. #endif
  1837.         if (strEQ(name, "DB_SET_RANGE"))
  1838. #ifdef DB_SET_RANGE
  1839.             return DB_SET_RANGE;
  1840. #else
  1841.             goto not_there;
  1842. #endif
  1843.         if (strEQ(name, "DB_SET_RECNO"))
  1844. #ifdef DB_SET_RECNO
  1845.             return DB_SET_RECNO;
  1846. #else
  1847.             goto not_there;
  1848. #endif
  1849.         if (strEQ(name, "DB_SNAPSHOT"))
  1850. #ifdef DB_SNAPSHOT
  1851.             return DB_SNAPSHOT;
  1852. #else
  1853.             goto not_there;
  1854. #endif
  1855.         if (strEQ(name, "DB_SWAPBYTES"))
  1856. #ifdef DB_SWAPBYTES
  1857.             return DB_SWAPBYTES;
  1858. #else
  1859.             goto not_there;
  1860. #endif
  1861.         if (strEQ(name, "DB_TEMPORARY"))
  1862. #ifdef DB_TEMPORARY
  1863.             return DB_TEMPORARY;
  1864. #else
  1865.             goto not_there;
  1866. #endif
  1867.         if (strEQ(name, "DB_THREAD"))
  1868. #ifdef DB_THREAD
  1869.             return DB_THREAD;
  1870. #else
  1871.             goto not_there;
  1872. #endif
  1873.         if (strEQ(name, "DB_TRUNCATE"))
  1874. #ifdef DB_TRUNCATE
  1875.             return DB_TRUNCATE;
  1876. #else
  1877.             goto not_there;
  1878. #endif
  1879.         if (strEQ(name, "DB_TXNMAGIC"))
  1880. #ifdef DB_TXNMAGIC
  1881.             return DB_TXNMAGIC;
  1882. #else
  1883.             goto not_there;
  1884. #endif
  1885.         if (strEQ(name, "DB_TXNVERSION"))
  1886. #ifdef DB_TXNVERSION
  1887.             return DB_TXNVERSION;
  1888. #else
  1889.             goto not_there;
  1890. #endif
  1891.         if (strEQ(name, "DB_TXN_BACKWARD_ROLL"))
  1892.             return DB_TXN_BACKWARD_ROLL;
  1893.         if (strEQ(name, "DB_TXN_CKP"))
  1894. #ifdef DB_TXN_CKP
  1895.             return DB_TXN_CKP;
  1896. #else
  1897.             goto not_there;
  1898. #endif
  1899.         if (strEQ(name, "DB_TXN_FORWARD_ROLL"))
  1900.             return DB_TXN_FORWARD_ROLL;
  1901.         if (strEQ(name, "DB_TXN_LOCK_2PL"))
  1902. #ifdef DB_TXN_LOCK_2PL
  1903.             return DB_TXN_LOCK_2PL;
  1904. #else
  1905.             goto not_there;
  1906. #endif
  1907.         if (strEQ(name, "DB_TXN_LOCK_MASK"))
  1908. #ifdef DB_TXN_LOCK_MASK
  1909.             return DB_TXN_LOCK_MASK;
  1910. #else
  1911.             goto not_there;
  1912. #endif
  1913.         if (strEQ(name, "DB_TXN_LOCK_OPTIMIST"))
  1914. #ifdef DB_TXN_LOCK_OPTIMIST
  1915.             return DB_TXN_LOCK_OPTIMIST;
  1916. #else
  1917.             goto not_there;
  1918. #endif
  1919.         if (strEQ(name, "DB_TXN_LOCK_OPTIMISTIC"))
  1920. #ifdef DB_TXN_LOCK_OPTIMISTIC
  1921.             return DB_TXN_LOCK_OPTIMISTIC;
  1922. #else
  1923.             goto not_there;
  1924. #endif
  1925.         if (strEQ(name, "DB_TXN_LOG_MASK"))
  1926. #ifdef DB_TXN_LOG_MASK
  1927.             return DB_TXN_LOG_MASK;
  1928. #else
  1929.             goto not_there;
  1930. #endif
  1931.         if (strEQ(name, "DB_TXN_LOG_REDO"))
  1932. #ifdef DB_TXN_LOG_REDO
  1933.             return DB_TXN_LOG_REDO;
  1934. #else
  1935.             goto not_there;
  1936. #endif
  1937.         if (strEQ(name, "DB_TXN_LOG_UNDO"))
  1938. #ifdef DB_TXN_LOG_UNDO
  1939.             return DB_TXN_LOG_UNDO;
  1940. #else
  1941.             goto not_there;
  1942. #endif
  1943.         if (strEQ(name, "DB_TXN_LOG_UNDOREDO"))
  1944. #ifdef DB_TXN_LOG_UNDOREDO
  1945.             return DB_TXN_LOG_UNDOREDO;
  1946. #else
  1947.             goto not_there;
  1948. #endif
  1949.         if (strEQ(name, "DB_TXN_NOSYNC"))
  1950. #ifdef DB_TXN_NOSYNC
  1951.             return DB_TXN_NOSYNC;
  1952. #else
  1953.             goto not_there;
  1954. #endif
  1955.         if (strEQ(name, "DB_TXN_NOWAIT"))
  1956. #ifdef DB_TXN_NOWAIT
  1957.             return DB_TXN_NOWAIT;
  1958. #else
  1959.             goto not_there;
  1960. #endif
  1961.         if (strEQ(name, "DB_TXN_OPENFILES"))
  1962.             return DB_TXN_OPENFILES;
  1963.         if (strEQ(name, "DB_TXN_REDO"))
  1964. #ifdef DB_TXN_REDO
  1965.             return DB_TXN_REDO;
  1966. #else
  1967.             goto not_there;
  1968. #endif
  1969.         if (strEQ(name, "DB_TXN_SYNC"))
  1970. #ifdef DB_TXN_SYNC
  1971.             return DB_TXN_SYNC;
  1972. #else
  1973.             goto not_there;
  1974. #endif
  1975.         if (strEQ(name, "DB_TXN_UNDO"))
  1976. #ifdef DB_TXN_UNDO
  1977.             return DB_TXN_UNDO;
  1978. #else
  1979.             goto not_there;
  1980. #endif
  1981.         if (strEQ(name, "DB_UNKNOWN"))
  1982.             return DB_UNKNOWN;
  1983.         if (strEQ(name, "DB_USE_ENVIRON"))
  1984. #ifdef DB_USE_ENVIRON
  1985.             return DB_USE_ENVIRON;
  1986. #else
  1987.             goto not_there;
  1988. #endif
  1989.         if (strEQ(name, "DB_USE_ENVIRON_ROOT"))
  1990. #ifdef DB_USE_ENVIRON_ROOT
  1991.             return DB_USE_ENVIRON_ROOT;
  1992. #else
  1993.             goto not_there;
  1994. #endif
  1995.         if (strEQ(name, "DB_VERSION_MAJOR"))
  1996. #ifdef DB_VERSION_MAJOR
  1997.             return DB_VERSION_MAJOR;
  1998. #else
  1999.             goto not_there;
  2000. #endif
  2001.         if (strEQ(name, "DB_VERSION_MINOR"))
  2002. #ifdef DB_VERSION_MINOR
  2003.             return DB_VERSION_MINOR;
  2004. #else
  2005.             goto not_there;
  2006. #endif
  2007.         if (strEQ(name, "DB_VERSION_PATCH"))
  2008. #ifdef DB_VERSION_PATCH
  2009.             return DB_VERSION_PATCH;
  2010. #else
  2011.             goto not_there;
  2012. #endif
  2013.         if (strEQ(name, "DB_WRITECURSOR"))
  2014. #ifdef DB_WRITECURSOR
  2015.             return DB_WRITECURSOR;
  2016. #else
  2017.             goto not_there;
  2018. #endif
  2019. break;
  2020.     case 'E':
  2021. break;
  2022.     case 'F':
  2023. break;
  2024.     case 'G':
  2025. break;
  2026.     case 'H':
  2027. break;
  2028.     case 'I':
  2029. break;
  2030.     case 'J':
  2031. break;
  2032.     case 'K':
  2033. break;
  2034.     case 'L':
  2035. break;
  2036.     case 'M':
  2037. break;
  2038.     case 'N':
  2039. break;
  2040.     case 'O':
  2041. break;
  2042.     case 'P':
  2043. break;
  2044.     case 'Q':
  2045. break;
  2046.     case 'R':
  2047. break;
  2048.     case 'S':
  2049. break;
  2050.     case 'T':
  2051. break;
  2052.     case 'U':
  2053. break;
  2054.     case 'V':
  2055. break;
  2056.     case 'W':
  2057. break;
  2058.     case 'X':
  2059. break;
  2060.     case 'Y':
  2061. break;
  2062.     case 'Z':
  2063. break;
  2064.     case 'a':
  2065. break;
  2066.     case 'b':
  2067. break;
  2068.     case 'c':
  2069. break;
  2070.     case 'd':
  2071. break;
  2072.     case 'e':
  2073. break;
  2074.     case 'f':
  2075. break;
  2076.     case 'g':
  2077. break;
  2078.     case 'h':
  2079. break;
  2080.     case 'i':
  2081. break;
  2082.     case 'j':
  2083. break;
  2084.     case 'k':
  2085. break;
  2086.     case 'l':
  2087. break;
  2088.     case 'm':
  2089. break;
  2090.     case 'n':
  2091. break;
  2092.     case 'o':
  2093. break;
  2094.     case 'p':
  2095. break;
  2096.     case 'q':
  2097. break;
  2098.     case 'r':
  2099. break;
  2100.     case 's':
  2101. break;
  2102.     case 't':
  2103. break;
  2104.     case 'u':
  2105. break;
  2106.     case 'v':
  2107. break;
  2108.     case 'w':
  2109. break;
  2110.     case 'x':
  2111. break;
  2112.     case 'y':
  2113. break;
  2114.     case 'z':
  2115. break;
  2116.     }
  2117.     errno = EINVAL;
  2118.     return 0;
  2120. not_there:
  2121.     errno = ENOENT;
  2122.     return 0;
  2123. }
  2126. MODULE = BerkeleyDB PACKAGE = BerkeleyDB PREFIX = env_
  2128. char *
  2129. DB_VERSION_STRING()
  2130. CODE:
  2131.   RETVAL = DB_VERSION_STRING ;
  2132. OUTPUT:
  2133.   RETVAL
  2136. double
  2137. constant(name,arg)
  2138. char * name
  2139. int arg
  2141. #define env_db_version(maj, min, patch)  db_version(&maj, &min, &patch)
  2142. char *
  2143. env_db_version(maj, min, patch)
  2144. int  maj
  2145. int  min
  2146. int  patch
  2147. OUTPUT:
  2148.   RETVAL
  2149.   maj
  2150.   min
  2151.   patch
  2153. int
  2154. db_value_set(value, which)
  2155. int value
  2156. int which
  2157.         NOT_IMPLEMENTED_YET
  2160. DualType
  2161. _db_remove(ref)
  2162. SV *  ref
  2163. CODE:
  2164. {
  2165. #if DB_VERSION_MAJOR == 2
  2166.     softCrash("BerkeleyDB::db_remove needs Berkeley DB 3.x or better") ;
  2167. #else
  2168.     HV * hash ;
  2169.          DB * dbp ;
  2170.     SV *  sv ;
  2171.     const char * db ;
  2172.     const char * subdb  = NULL ;
  2173.     BerkeleyDB__Env env  = NULL ;
  2174.          DB_ENV * dbenv   = NULL ;
  2175.     u_int32_t flags = 0 ;
  2177.     hash = (HV*) SvRV(ref) ;
  2178.     SetValue_pv(db,    "Filename", char *) ;
  2179.     SetValue_pv(subdb, "Subname", char *) ;
  2180.     SetValue_iv(flags, "Flags") ;
  2181.     SetValue_ov(env, "Env", BerkeleyDB__Env) ;
  2182.          if (env)
  2183. dbenv = env->Env ;
  2184.             RETVAL = db_create(&dbp, dbenv, 0) ;
  2185.     if (RETVAL == 0) {
  2186.         RETVAL = dbp->remove(dbp, db, subdb, flags) ;
  2187.     }
  2188. #endif
  2189. }
  2190. OUTPUT:
  2191.     RETVAL
  2193. MODULE = BerkeleyDB::Env PACKAGE = BerkeleyDB::Env PREFIX = env_
  2196. BerkeleyDB::Env::Raw
  2197. _db_appinit(self, ref)
  2198. char * self
  2199. SV *  ref
  2200. CODE:
  2201. {
  2202.     HV * hash ;
  2203.     SV * sv ;
  2204.     char * home = NULL ;
  2205.     char *  server = NULL ;
  2206.     char ** config = NULL ;
  2207.     int flags = 0 ;
  2208.     int cachesize = 0 ;
  2209.     int lk_detect = 0 ;
  2210.     int mode = 0 ;
  2211.     SV * errprefix = NULL;
  2212.     DB_ENV * env ;
  2213.     int status ;
  2215.     Trace(("in _db_appinit [%s] %dn", self, ref)) ;
  2216.     hash = (HV*) SvRV(ref) ;
  2217.     SetValue_pv(home,      "Home", char *) ;
  2218.     SetValue_pv(config,    "Config", char **) ;
  2219.     SetValue_sv(errprefix, "ErrPrefix") ;
  2220.     SetValue_iv(flags,     "Flags") ;
  2221.     SetValue_pv(server,    "Server", char *) ;
  2222.     SetValue_iv(cachesize, "Cachesize") ;
  2223.     SetValue_iv(lk_detect, "LockDetect") ;
  2224. #ifndef AT_LEAST_DB_3_1
  2225.     if (server)
  2226.         softCrash("-Server needs Berkeley DB 3.1 or better") ;
  2227. #endif /* ! AT_LEAST_DB_3_1 */
  2228.     Trace(("_db_appinit(config=[%d], home=[%s],errprefix=[%s],flags=[%d]n",
  2229. config, home, errprefix, flags)) ;
  2230. #ifdef TRACE
  2231.     if (config) {
  2232.        int i ;
  2233.       for (i = 0 ; i < 10 ; ++ i) {
  2234. if (config[i] == NULL) {
  2235.     printf("    Endn") ;
  2236.     break ;
  2237. }
  2238.         printf("    config = [%s]n", config[i]) ;
  2239.       }
  2240.     }
  2241. #endif /* TRACE */
  2242.     ZMALLOC(RETVAL, BerkeleyDB_ENV_type) ;
  2243.     if (flags & DB_INIT_TXN)
  2244.         RETVAL->txn_enabled = TRUE ;
  2245. #if DB_VERSION_MAJOR == 2
  2246.   ZMALLOC(RETVAL->Env, DB_ENV) ;
  2247.   env = RETVAL->Env ;
  2248.   {
  2249.     /* Take a copy of the error prefix */
  2250.     if (errprefix) {
  2251.         Trace(("copying errprefixn" )) ;
  2252. RETVAL->ErrPrefix = newSVsv(errprefix) ;
  2253. SvPOK_only(RETVAL->ErrPrefix) ;
  2254.     }
  2255.     if (RETVAL->ErrPrefix)
  2256.         RETVAL->Env->db_errpfx = SvPVX(RETVAL->ErrPrefix) ;
  2258.     if ((sv = readHash(hash, "ErrFile")) && sv != &PL_sv_undef) {
  2259. env->db_errfile = IoOFP(sv_2io(sv)) ;
  2260. RETVAL->ErrHandle = newRV(sv) ;
  2261.     }
  2262.     /* SetValue_io(RETVAL->Env.db_errfile, "ErrFile") ; */
  2263.     SetValue_iv(env->db_verbose, "Verbose") ;
  2264.     /* env->db_errbuf = RETVAL->ErrBuff ; */
  2265.     env->db_errcall = db_errcall_cb ;
  2266.     RETVAL->active = TRUE ;
  2267.     status = db_appinit(home, config, env, flags) ;
  2268.     Trace(("  status = %d env %d Env %dn", status, RETVAL, env)) ;
  2269.     if (status == 0)
  2270.         hash_store_iv("BerkeleyDB::Term::Env", (IV)RETVAL, 1) ;
  2271.     else {
  2272.                 if (RETVAL->ErrHandle)
  2273.                     SvREFCNT_dec(RETVAL->ErrHandle) ;
  2274.                 if (RETVAL->ErrPrefix)
  2275.                     SvREFCNT_dec(RETVAL->ErrPrefix) ;
  2276.                 Safefree(RETVAL->Env) ;
  2277.                 Safefree(RETVAL) ;
  2278. RETVAL = NULL ;
  2279.     }
  2280.   }
  2281. #else /* DB_VERSION_MAJOR > 2 */
  2282. #ifndef AT_LEAST_DB_3_1
  2283. #    define DB_CLIENT 0
  2284. #endif
  2285.   status = db_env_create(&RETVAL->Env, server ? DB_CLIENT : 0) ;
  2286.   Trace(("db_env_create flags = %d returned %sn", flags,
  2287.    my_db_strerror(status))) ;
  2288.   env = RETVAL->Env ;
  2289.   if (status == 0 && cachesize) {
  2290.       status = env->set_cachesize(env, 0, cachesize, 0) ;
  2291.       Trace(("set_cachesize [%d] returned %sn",
  2292. cachesize, my_db_strerror(status)));
  2293.   }
  2295.   if (status == 0 && lk_detect) {
  2296.       status = env->set_lk_detect(env, lk_detect) ;
  2297.       Trace(("set_lk_detect [%d] returned %sn",
  2298.               lk_detect, my_db_strerror(status)));
  2299.   }
  2300. #ifdef AT_LEAST_DB_3_1
  2301.   /* set the server */
  2302.   if (server && status == 0)
  2303.   {
  2304.       status = env->set_server(env, server, 0, 0, 0);
  2305.       Trace(("ENV->set_server server = %s returned %sn", server,
  2306.    my_db_strerror(status))) ;
  2307.   }
  2308. #endif
  2309.   if (status == 0)
  2310.   {
  2311.     /* Take a copy of the error prefix */
  2312.     if (errprefix) {
  2313.         Trace(("copying errprefixn" )) ;
  2314. RETVAL->ErrPrefix = newSVsv(errprefix) ;
  2315. SvPOK_only(RETVAL->ErrPrefix) ;
  2316.     }
  2317.     if (RETVAL->ErrPrefix)
  2318.         env->set_errpfx(env, SvPVX(RETVAL->ErrPrefix)) ;
  2320.     if ((sv = readHash(hash, "ErrFile")) && sv != &PL_sv_undef) {
  2321. env->set_errfile(env, IoOFP(sv_2io(sv))) ;
  2322. RETVAL->ErrHandle = newRV(sv) ;
  2323.     }
  2324.     /* SetValue_iv(RETVAL->Env.db_verbose, "Verbose") ; */ /* TODO */
  2325.     SetValue_iv(mode, "Mode") ;
  2326.     /* RETVAL->Env.db_errbuf = RETVAL->ErrBuff ; */
  2327.     env->set_errcall(env, db_errcall_cb) ;
  2328.     RETVAL->active = TRUE ;
  2329. #ifdef IS_DB_3_0
  2330.     status = (env->open)(env, home, config, flags, mode) ;
  2331. #else /* > 3.0 */
  2332.     status = (env->open)(env, home, flags, mode) ;
  2333. #endif
  2334.     Trace(("ENV->open returned %sn", my_db_strerror(status))) ;
  2335.   }
  2337.   if (status == 0)
  2338.       hash_store_iv("BerkeleyDB::Term::Env", (IV)RETVAL, 1) ;
  2339.   else {
  2340.       (env->close)(env, 0) ;
  2341.               if (RETVAL->ErrHandle)
  2342.                   SvREFCNT_dec(RETVAL->ErrHandle) ;
  2343.               if (RETVAL->ErrPrefix)
  2344.                   SvREFCNT_dec(RETVAL->ErrPrefix) ;
  2345.               Safefree(RETVAL) ;
  2346.       RETVAL = NULL ;
  2347.   }
  2348. #endif /* DB_VERSION_MAJOR > 2 */
  2349. }
  2350. OUTPUT:
  2351.     RETVAL
  2353. BerkeleyDB::Txn::Raw
  2354. _txn_begin(env, pid=NULL, flags=0)
  2355. BerkeleyDB::Env env
  2356. BerkeleyDB::Txn pid
  2357. u_int32_t flags
  2358. CODE:
  2359. {
  2360.     DB_TXN *txn ;
  2361.     DB_TXN *p_id = NULL ;
  2362.     Trace(("txn_begin pid %d, flags %dn", pid, flags)) ;
  2363. #if DB_VERSION_MAJOR == 2
  2364.     if (env->Env->tx_info == NULL)
  2365. softCrash("Transaction Manager not enabled") ;
  2366. #endif
  2367.     if (!env->txn_enabled)
  2368. softCrash("Transaction Manager not enabled") ;
  2369.     if (pid)
  2370. p_id = pid->txn ;
  2371.     env->TxnMgrStatus =
  2372. #if DB_VERSION_MAJOR == 2
  2373.      txn_begin(env->Env->tx_info, p_id, &txn) ;
  2374. #else
  2375.      txn_begin(env->Env, p_id, &txn, flags) ;
  2376. #endif
  2377.     if (env->TxnMgrStatus == 0) {
  2378.       ZMALLOC(RETVAL, BerkeleyDB_Txn_type) ;
  2379.       RETVAL->txn  = txn ;
  2380.       RETVAL->active = TRUE ;
  2381.       Trace(("_txn_begin created txn [%d] in [%d]n", txn, RETVAL));
  2382.       hash_store_iv("BerkeleyDB::Term::Txn", (IV)RETVAL, 1) ;
  2383.     }
  2384.     else
  2385. RETVAL = NULL ;
  2386. }
  2387. OUTPUT:
  2388.     RETVAL
  2391. #if DB_VERSION_MAJOR == 2
  2392. #  define env_txn_checkpoint(e,k,m) txn_checkpoint(e->Env->tx_info, k, m)
  2393. #else /* DB 3.0 or better */
  2394. #  ifdef AT_LEAST_DB_3_1
  2395. #    define env_txn_checkpoint(e,k,m) txn_checkpoint(e->Env, k, m, 0)
  2396. #  else
  2397. #    define env_txn_checkpoint(e,k,m) txn_checkpoint(e->Env, k, m)
  2398. #  endif
  2399. #endif
  2400. DualType
  2401. env_txn_checkpoint(env, kbyte, min)
  2402. BerkeleyDB::Env env
  2403. long kbyte
  2404. long min
  2406. HV *
  2407. txn_stat(env)
  2408. BerkeleyDB::Env env
  2409. HV * RETVAL = NULL ;
  2410. CODE:
  2411. {
  2412.     DB_TXN_STAT * stat ;
  2413. #if DB_VERSION_MAJOR == 2
  2414.     if(txn_stat(env->Env->tx_info, &stat, safemalloc) == 0) {
  2415. #else
  2416.     if(txn_stat(env->Env, &stat, safemalloc) == 0) {
  2417. #endif
  2418.      RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
  2419. hv_store_iv(RETVAL, "st_time_ckp", stat->st_time_ckp) ;
  2420. hv_store_iv(RETVAL, "st_last_txnid", stat->st_last_txnid) ;
  2421. hv_store_iv(RETVAL, "st_maxtxns", stat->st_maxtxns) ;
  2422. hv_store_iv(RETVAL, "st_naborts", stat->st_naborts) ;
  2423. hv_store_iv(RETVAL, "st_nbegins", stat->st_nbegins) ;
  2424. hv_store_iv(RETVAL, "st_ncommits", stat->st_ncommits) ;
  2425. hv_store_iv(RETVAL, "st_nactive", stat->st_nactive) ;
  2426. #if DB_VERSION_MAJOR > 2
  2427. hv_store_iv(RETVAL, "st_maxnactive", stat->st_maxnactive) ;
  2428. hv_store_iv(RETVAL, "st_regsize", stat->st_regsize) ;
  2429. hv_store_iv(RETVAL, "st_region_wait", stat->st_region_wait) ;
  2430. hv_store_iv(RETVAL, "st_region_nowait", stat->st_region_nowait) ;
  2431. #endif
  2432. safefree(stat) ;
  2433.     }
  2434. }
  2435. OUTPUT:
  2436.     RETVAL
  2438. #define EnDis(x) ((x) ? "Enabled" : "Disabled")
  2439. void
  2440. printEnv(env)
  2441.         BerkeleyDB::Env  env
  2442. INIT:
  2443.     ckActive_Environment(env->active) ;
  2444. CODE:
  2445. #if 0
  2446.   printf("env             [0x%X]n", env) ;
  2447.   printf("  ErrPrefix     [%s]n", env->ErrPrefix
  2448.            ? SvPVX(env->ErrPrefix) : 0) ;
  2449.   printf("  DB_ENVn") ;
  2450.   printf("    db_lorder   [%d]n", env->Env.db_lorder) ;
  2451.   printf("    db_home     [%s]n", env->Env.db_home) ;
  2452.   printf("    db_data_dir [%s]n", env->Env.db_data_dir) ;
  2453.   printf("    db_log_dir  [%s]n", env->Env.db_log_dir) ;
  2454.   printf("    db_tmp_dir  [%s]n", env->Env.db_tmp_dir) ;
  2455.   printf("    lk_info     [%s]n", EnDis(env->Env.lk_info)) ;
  2456.   printf("    lk_max      [%d]n", env->Env.lk_max) ;
  2457.   printf("    lg_info     [%s]n", EnDis(env->Env.lg_info)) ;
  2458.   printf("    lg_max      [%d]n", env->Env.lg_max) ;
  2459.   printf("    mp_info     [%s]n", EnDis(env->Env.mp_info)) ;
  2460.   printf("    mp_size     [%d]n", env->Env.mp_size) ;
  2461.   printf("    tx_info     [%s]n", EnDis(env->Env.tx_info)) ;
  2462.   printf("    tx_max      [%d]n", env->Env.tx_max) ;
  2463.   printf("    flags       [%d]n", env->Env.flags) ;
  2464.   printf("n") ;
  2465. #endif
  2467. SV *
  2468. errPrefix(env, prefix)
  2469.         BerkeleyDB::Env  env
  2470. SV *   prefix
  2471. INIT:
  2472.     ckActive_Environment(env->active) ;
  2473. CODE:
  2474.   if (env->ErrPrefix) {
  2475.       RETVAL = newSVsv(env->ErrPrefix) ;
  2476.               SvPOK_only(RETVAL) ;
  2477.       sv_setsv(env->ErrPrefix, prefix) ;
  2478.   }
  2479.   else {
  2480.       RETVAL = NULL ;
  2481.       env->ErrPrefix = newSVsv(prefix) ;
  2482.   }
  2483.   SvPOK_only(env->ErrPrefix) ;
  2484. #if DB_VERSION_MAJOR == 2
  2485.   env->Env->db_errpfx = SvPVX(env->ErrPrefix) ;
  2486. #else
  2487.   env->Env->set_errpfx(env->Env, SvPVX(env->ErrPrefix)) ;
  2488. #endif
  2489. OUTPUT:
  2490.   RETVAL
  2492. DualType
  2493. status(env)
  2494.         BerkeleyDB::Env  env
  2495. CODE:
  2496.     RETVAL =  env->Status ;
  2497. OUTPUT:
  2498.     RETVAL
  2500. DualType
  2501. db_appexit(env)
  2502.         BerkeleyDB::Env  env
  2503. INIT:
  2504.     ckActive_Environment(env->active) ;
  2505. CODE:
  2506. #ifdef STRICT_CLOSE
  2507.     if (env->open_dbs)
  2508. softCrash("attempted to close an environment with %d open database(s)",
  2509. env->open_dbs) ;
  2510. #endif /* STRICT_CLOSE */
  2511. #if DB_VERSION_MAJOR == 2
  2512.     RETVAL = db_appexit(env->Env) ;
  2513. #else
  2514.     RETVAL = (env->Env->close)(env->Env, 0) ;
  2515. #endif
  2516.     env->active = FALSE ;
  2517.     hash_delete("BerkeleyDB::Term::Env", (IV)env) ;
  2518. OUTPUT:
  2519.     RETVAL
  2522. void
  2523. _DESTROY(env)
  2524.         BerkeleyDB::Env  env
  2525. int RETVAL = 0 ;
  2526. CODE:
  2527.   Trace(("In BerkeleyDB::Env::DESTROYn"));
  2528.   Trace(("    env %ld Env %ld dirty %dn", env, &env->Env, PL_dirty)) ;
  2529.   if (env->active)
  2530. #if DB_VERSION_MAJOR == 2
  2531.               db_appexit(env->Env) ;
  2532. #else
  2533.       (env->Env->close)(env->Env, 0) ;
  2534. #endif
  2535.           if (env->ErrHandle)
  2536.               SvREFCNT_dec(env->ErrHandle) ;
  2537.           if (env->ErrPrefix)
  2538.               SvREFCNT_dec(env->ErrPrefix) ;
  2539. #if DB_VERSION_MAJOR == 2
  2540.           Safefree(env->Env) ;
  2541. #endif
  2542.           Safefree(env) ;
  2543.   hash_delete("BerkeleyDB::Term::Env", (IV)env) ;
  2544.   Trace(("End of BerkeleyDB::Env::DESTROY %dn", RETVAL)) ;
  2546. BerkeleyDB::TxnMgr::Raw
  2547. _TxnMgr(env)
  2548.         BerkeleyDB::Env  env
  2549. INIT:
  2550.     ckActive_Environment(env->active) ;
  2551.     if (!env->txn_enabled)
  2552. softCrash("Transaction Manager not enabled") ;
  2553. CODE:
  2554.     ZMALLOC(RETVAL, BerkeleyDB_TxnMgr_type) ;
  2555.     RETVAL->env  = env ;
  2556.     /* hash_store_iv("BerkeleyDB::Term::TxnMgr", (IV)txn, 1) ; */
  2557. OUTPUT:
  2558.     RETVAL
  2560. int
  2561. set_data_dir(env, dir)
  2562.         BerkeleyDB::Env  env
  2563. char *  dir
  2564. INIT:
  2565.   ckActive_Database(env->active) ;
  2566. CODE:
  2567. #ifndef AT_LEAST_DB_3_1
  2568.     softCrash("$env->set_data_dir needs Berkeley DB 3.1 or better") ;
  2569. #else
  2570.     RETVAL = env->Status = env->Env->set_data_dir(env->Env, dir);
  2571. #endif
  2572. OUTPUT:
  2573.     RETVAL
  2575. int
  2576. set_lg_dir(env, dir)
  2577.         BerkeleyDB::Env  env
  2578. char *  dir
  2579. INIT:
  2580.   ckActive_Database(env->active) ;
  2581. CODE:
  2582. #ifndef AT_LEAST_DB_3_1
  2583.     softCrash("$env->set_lg_dir needs Berkeley DB 3.1 or better") ;
  2584. #else
  2585.     RETVAL = env->Status = env->Env->set_lg_dir(env->Env, dir);
  2586. #endif
  2587. OUTPUT:
  2588.     RETVAL
  2590. int
  2591. set_tmp_dir(env, dir)
  2592.         BerkeleyDB::Env  env
  2593. char *  dir
  2594. INIT:
  2595.   ckActive_Database(env->active) ;
  2596. CODE:
  2597. #ifndef AT_LEAST_DB_3_1
  2598.     softCrash("$env->set_tmp_dir needs Berkeley DB 3.1 or better") ;
  2599. #else
  2600.     RETVAL = env->Status = env->Env->set_tmp_dir(env->Env, dir);
  2601. #endif
  2602. OUTPUT:
  2603.     RETVAL
  2605. int
  2606. set_mutexlocks(env, do_lock)
  2607.         BerkeleyDB::Env  env
  2608. int   do_lock
  2609. INIT:
  2610.   ckActive_Database(env->active) ;
  2611. CODE:
  2612. #ifndef AT_LEAST_DB_3
  2613.     softCrash("$env->set_setmutexlocks needs Berkeley DB 3.0 or better") ;
  2614. #else
  2615. #if defined(IS_DB_3_0) || defined(AT_LEAST_DB_3_2)
  2616.     RETVAL = env->Status = env->Env->set_mutexlocks(env->Env, do_lock);
  2617. #else /* DB 3.1 */
  2618.     RETVAL = env->Status = db_env_set_mutexlocks(do_lock);
  2619. #endif
  2620. #endif
  2621. OUTPUT:
  2622.     RETVAL
  2624. MODULE = BerkeleyDB::Term PACKAGE = BerkeleyDB::Term
  2626. void
  2627. close_everything()
  2629. #define safeCroak(string) softCrash(string)
  2630. void
  2631. safeCroak(string)
  2632. char * string
  2634. MODULE = BerkeleyDB::Hash PACKAGE = BerkeleyDB::Hash PREFIX = hash_
  2636. BerkeleyDB::Hash::Raw
  2637. _db_open_hash(self, ref)
  2638. char * self
  2639. SV *  ref
  2640. CODE:
  2641. {
  2642.     HV * hash ;
  2643.     SV *  sv ;
  2644.     DB_INFO  info ;
  2645.     BerkeleyDB__Env dbenv = NULL;
  2646.     SV * ref_dbenv = NULL;
  2647.     const char * file = NULL ;
  2648.     const char * subname = NULL ;
  2649.     int flags = 0 ;
  2650.     int mode = 0 ;
  2651.          BerkeleyDB  db ;
  2653.          Trace(("_db_open_hash startn")) ;
  2654.     hash = (HV*) SvRV(ref) ;
  2655.     SetValue_pv(file, "Filename", char *) ;
  2656.     SetValue_pv(subname, "Subname", char *) ;
  2657.     SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
  2658.     ref_dbenv = sv ;
  2659.     SetValue_iv(flags, "Flags") ;
  2660.     SetValue_iv(mode, "Mode") ;
  2662.             Zero(&info, 1, DB_INFO) ;
  2663.     SetValue_iv(info.db_cachesize, "Cachesize") ;
  2664.     SetValue_iv(info.db_lorder, "Lorder") ;
  2665.     SetValue_iv(info.db_pagesize, "Pagesize") ;
  2666.     SetValue_iv(info.h_ffactor, "Ffactor") ;
  2667.     SetValue_iv(info.h_nelem, "Nelem") ;
  2668.     SetValue_iv(info.flags, "Property") ;
  2669.     ZMALLOC(db, BerkeleyDB_type) ;
  2670.     if ((sv = readHash(hash, "Hash")) && sv != &PL_sv_undef) {
  2671. info.h_hash = hash_cb ;
  2672. db->hash = newSVsv(sv) ;
  2673.     }
  2674.     /* DB_DUPSORT was introduced in DB 2.5.9 */
  2675.     if ((sv = readHash(hash, "DupCompare")) && sv != &PL_sv_undef) {
  2676. #ifdef DB_DUPSORT
  2677. info.dup_compare = dup_compare ;
  2678. db->dup_compare = newSVsv(sv) ;
  2679. info.flags |= DB_DUP|DB_DUPSORT ;
  2680. #else
  2681.         croak("DupCompare needs Berkeley DB 2.5.9 or later") ;
  2682. #endif
  2683.     }
  2684.     RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, file, subname, DB_HASH, flags, mode, &info) ;
  2685.          Trace(("_db_open_hash endn")) ;
  2686. }
  2687. OUTPUT:
  2688.     RETVAL
  2691. HV *
  2692. db_stat(db, flags=0)
  2693. BerkeleyDB::Common db
  2694. int flags
  2695. HV * RETVAL = NULL ;
  2696. INIT:
  2697.   ckActive_Database(db->active) ;
  2698. CODE:
  2699. {
  2700. #if DB_VERSION_MAJOR == 2
  2701.     softCrash("$db->db_stat for a Hash needs Berkeley DB 3.x or better") ;
  2702. #else
  2703.     DB_HASH_STAT * stat ;
  2704.     db->Status = ((db->dbp)->stat)(db->dbp, &stat, safemalloc, flags) ;
  2705.     if (db->Status == 0) {
  2706.      RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
  2707. hv_store_iv(RETVAL, "hash_magic", stat->hash_magic) ;
  2708. hv_store_iv(RETVAL, "hash_version", stat->hash_version);
  2709. hv_store_iv(RETVAL, "hash_pagesize", stat->hash_pagesize);
  2710. #ifdef AT_LEAST_DB_3_1
  2711. hv_store_iv(RETVAL, "hash_nkeys", stat->hash_nkeys);
  2712. hv_store_iv(RETVAL, "hash_ndata", stat->hash_ndata);
  2713. #else
  2714. hv_store_iv(RETVAL, "hash_nrecs", stat->hash_nrecs);
  2715. #endif
  2716. hv_store_iv(RETVAL, "hash_nelem", stat->hash_nelem);
  2717. hv_store_iv(RETVAL, "hash_ffactor", stat->hash_ffactor);
  2718. hv_store_iv(RETVAL, "hash_buckets", stat->hash_buckets);
  2719. hv_store_iv(RETVAL, "hash_free", stat->hash_free);
  2720. hv_store_iv(RETVAL, "hash_bfree", stat->hash_bfree);
  2721. hv_store_iv(RETVAL, "hash_bigpages", stat->hash_bigpages);
  2722. hv_store_iv(RETVAL, "hash_big_bfree", stat->hash_big_bfree);
  2723. hv_store_iv(RETVAL, "hash_overflows", stat->hash_overflows);
  2724. hv_store_iv(RETVAL, "hash_ovfl_free", stat->hash_ovfl_free);
  2725. hv_store_iv(RETVAL, "hash_dup", stat->hash_dup);
  2726. hv_store_iv(RETVAL, "hash_dup_free", stat->hash_dup_free);
  2727. #if DB_VERSION_MAJOR >= 3
  2728. hv_store_iv(RETVAL, "hash_metaflags", stat->hash_metaflags);
  2729. #endif
  2730. safefree(stat) ;
  2731.     }
  2732. #endif
  2733. }
  2734. OUTPUT:
  2735.     RETVAL
  2738. MODULE = BerkeleyDB::Unknown PACKAGE = BerkeleyDB::Unknown PREFIX = hash_
  2740. void
  2741. _db_open_unknown(ref)
  2742. SV *  ref
  2743. PPCODE:
  2744. {
  2745.     HV * hash ;
  2746.     SV *  sv ;
  2747.     DB_INFO  info ;
  2748.     BerkeleyDB__Env dbenv = NULL;
  2749.     SV * ref_dbenv = NULL;
  2750.     const char * file = NULL ;
  2751.     const char * subname = NULL ;
  2752.     int flags = 0 ;
  2753.     int mode = 0 ;
  2754.          BerkeleyDB  db ;
  2755.     BerkeleyDB RETVAL ;
  2756.     static char *  Names[] = {"", "Btree", "Hash", "Recno"} ;
  2758.     hash = (HV*) SvRV(ref) ;
  2759.     SetValue_pv(file, "Filename", char *) ;
  2760.     SetValue_pv(subname, "Subname", char *) ;
  2761.     SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
  2762.     ref_dbenv = sv ;
  2763.     SetValue_iv(flags, "Flags") ;
  2764.     SetValue_iv(mode, "Mode") ;
  2766.             Zero(&info, 1, DB_INFO) ;
  2767.     SetValue_iv(info.db_cachesize, "Cachesize") ;
  2768.     SetValue_iv(info.db_lorder, "Lorder") ;
  2769.     SetValue_iv(info.db_pagesize, "Pagesize") ;
  2770.     SetValue_iv(info.h_ffactor, "Ffactor") ;
  2771.     SetValue_iv(info.h_nelem, "Nelem") ;
  2772.     SetValue_iv(info.flags, "Property") ;
  2773.     ZMALLOC(db, BerkeleyDB_type) ;
  2775.     RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, file, subname, DB_UNKNOWN, flags, mode, &info) ;
  2776.     XPUSHs(sv_2mortal(newSViv((IV)RETVAL)));
  2777.     if (RETVAL)
  2778.         XPUSHs(sv_2mortal(newSVpv(Names[RETVAL->type], 0))) ;
  2779.     else
  2780.         XPUSHs(sv_2mortal(newSViv((IV)NULL)));
  2781. }
  2785. MODULE = BerkeleyDB::Btree PACKAGE = BerkeleyDB::Btree PREFIX = btree_
  2787. BerkeleyDB::Btree::Raw
  2788. _db_open_btree(self, ref)
  2789. char * self
  2790. SV *  ref
  2791. CODE:
  2792. {
  2793.     HV * hash ;
  2794.     SV *  sv ;
  2795.     DB_INFO  info ;
  2796.     BerkeleyDB__Env dbenv = NULL;
  2797.     SV * ref_dbenv = NULL;
  2798.     const char * file = NULL ;
  2799.     const char * subname = NULL ;
  2800.     int flags = 0 ;
  2801.     int mode = 0 ;
  2802.          BerkeleyDB   db ;
  2804.     hash = (HV*) SvRV(ref) ;
  2805.     SetValue_pv(file, "Filename", char*) ;
  2806.     SetValue_pv(subname, "Subname", char *) ;
  2807.     SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
  2808.     ref_dbenv = sv ;
  2809.     SetValue_iv(flags, "Flags") ;
  2810.     SetValue_iv(mode, "Mode") ;
  2812.             Zero(&info, 1, DB_INFO) ;
  2813.     SetValue_iv(info.db_cachesize, "Cachesize") ;
  2814.     SetValue_iv(info.db_lorder, "Lorder") ;
  2815.     SetValue_iv(info.db_pagesize, "Pagesize") ;
  2816.     SetValue_iv(info.bt_minkey, "Minkey") ;
  2817.     SetValue_iv(info.flags, "Property") ;
  2818.     ZMALLOC(db, BerkeleyDB_type) ;
  2819.     if ((sv = readHash(hash, "Compare")) && sv != &PL_sv_undef) {
  2820. info.bt_compare = btree_compare ;
  2821. db->compare = newSVsv(sv) ;
  2822.     }
  2823.     /* DB_DUPSORT was introduced in DB 2.5.9 */
  2824.     if ((sv = readHash(hash, "DupCompare")) && sv != &PL_sv_undef) {
  2825. #ifdef DB_DUPSORT
  2826. info.dup_compare = dup_compare ;
  2827. db->dup_compare = newSVsv(sv) ;
  2828. info.flags |= DB_DUP|DB_DUPSORT ;
  2829. #else
  2830.         softCrash("DupCompare needs Berkeley DB 2.5.9 or later") ;
  2831. #endif
  2832.     }
  2833.     if ((sv = readHash(hash, "Prefix")) && sv != &PL_sv_undef) {
  2834. info.bt_prefix = btree_prefix ;
  2835. db->prefix = newSVsv(sv) ;
  2836.     }
  2838.     RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, file, subname, DB_BTREE, flags, mode, &info) ;
  2839. }
  2840. OUTPUT:
  2841.     RETVAL
  2844. HV *
  2845. db_stat(db, flags=0)
  2846. BerkeleyDB::Common db
  2847. int flags
  2848. HV * RETVAL = NULL ;
  2849. INIT:
  2850.   ckActive_Database(db->active) ;
  2851. CODE:
  2852. {
  2853.     DB_BTREE_STAT * stat ;
  2854.     db->Status = ((db->dbp)->stat)(db->dbp, &stat, safemalloc, flags) ;
  2855.     if (db->Status == 0) {
  2856.      RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
  2857. hv_store_iv(RETVAL, "bt_magic", stat->bt_magic);
  2858. hv_store_iv(RETVAL, "bt_version", stat->bt_version);
  2859. #if DB_VERSION_MAJOR > 2
  2860. hv_store_iv(RETVAL, "bt_metaflags", stat->bt_metaflags) ;
  2861. hv_store_iv(RETVAL, "bt_flags", stat->bt_metaflags) ;
  2862. #else
  2863. hv_store_iv(RETVAL, "bt_flags", stat->bt_flags) ;
  2864. #endif
  2865. hv_store_iv(RETVAL, "bt_maxkey", stat->bt_maxkey) ;
  2866. hv_store_iv(RETVAL, "bt_minkey", stat->bt_minkey);
  2867. hv_store_iv(RETVAL, "bt_re_len", stat->bt_re_len);
  2868. hv_store_iv(RETVAL, "bt_re_pad", stat->bt_re_pad);
  2869. hv_store_iv(RETVAL, "bt_pagesize", stat->bt_pagesize);
  2870. hv_store_iv(RETVAL, "bt_levels", stat->bt_levels);
  2871. #ifdef AT_LEAST_DB_3_1
  2872. hv_store_iv(RETVAL, "bt_nkeys", stat->bt_nkeys);
  2873. hv_store_iv(RETVAL, "bt_ndata", stat->bt_ndata);
  2874. #else
  2875. hv_store_iv(RETVAL, "bt_nrecs", stat->bt_nrecs);
  2876. #endif
  2877. hv_store_iv(RETVAL, "bt_int_pg", stat->bt_int_pg);
  2878. hv_store_iv(RETVAL, "bt_leaf_pg", stat->bt_leaf_pg);
  2879. hv_store_iv(RETVAL, "bt_dup_pg", stat->bt_dup_pg);
  2880. hv_store_iv(RETVAL, "bt_over_pg", stat->bt_over_pg);
  2881. hv_store_iv(RETVAL, "bt_free", stat->bt_free);
  2882. #if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 5
  2883. hv_store_iv(RETVAL, "bt_freed", stat->bt_freed);
  2884. hv_store_iv(RETVAL, "bt_pfxsaved", stat->bt_pfxsaved);
  2885. hv_store_iv(RETVAL, "bt_split", stat->bt_split);
  2886. hv_store_iv(RETVAL, "bt_rootsplit", stat->bt_rootsplit);
  2887. hv_store_iv(RETVAL, "bt_fastsplit", stat->bt_fastsplit);
  2888. hv_store_iv(RETVAL, "bt_added", stat->bt_added);
  2889. hv_store_iv(RETVAL, "bt_deleted", stat->bt_deleted);
  2890. hv_store_iv(RETVAL, "bt_get", stat->bt_get);
  2891. hv_store_iv(RETVAL, "bt_cache_hit", stat->bt_cache_hit);
  2892. hv_store_iv(RETVAL, "bt_cache_miss", stat->bt_cache_miss);
  2893. #endif
  2894. hv_store_iv(RETVAL, "bt_int_pgfree", stat->bt_int_pgfree);
  2895. hv_store_iv(RETVAL, "bt_leaf_pgfree", stat->bt_leaf_pgfree);
  2896. hv_store_iv(RETVAL, "bt_dup_pgfree", stat->bt_dup_pgfree);
  2897. hv_store_iv(RETVAL, "bt_over_pgfree", stat->bt_over_pgfree);
  2898. safefree(stat) ;
  2899.     }
  2900. }
  2901. OUTPUT:
  2902.     RETVAL
  2905. MODULE = BerkeleyDB::Recno PACKAGE = BerkeleyDB::Recno PREFIX = recno_
  2907. BerkeleyDB::Recno::Raw
  2908. _db_open_recno(self, ref)
  2909. char * self
  2910. SV *  ref
  2911. CODE:
  2912. {
  2913.     HV * hash ;
  2914.     SV *  sv ;
  2915.     DB_INFO  info ;
  2916.     BerkeleyDB__Env dbenv = NULL;
  2917.     SV * ref_dbenv = NULL;
  2918.     const char * file = NULL ;
  2919.     const char * subname = NULL ;
  2920.     int flags = 0 ;
  2921.     int mode = 0 ;
  2922.          BerkeleyDB  db ;
  2924.     hash = (HV*) SvRV(ref) ;
  2925.     SetValue_pv(file, "Fname", char*) ;
  2926.     SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
  2927.     ref_dbenv = sv ;
  2928.     SetValue_iv(flags, "Flags") ;
  2929.     SetValue_iv(mode, "Mode") ;
  2931.             Zero(&info, 1, DB_INFO) ;
  2932.     SetValue_iv(info.db_cachesize, "Cachesize") ;
  2933.     SetValue_iv(info.db_lorder, "Lorder") ;
  2934.     SetValue_iv(info.db_pagesize, "Pagesize") ;
  2935.     SetValue_iv(info.bt_minkey, "Minkey") ;
  2937.     SetValue_iv(info.flags, "Property") ;
  2938.     SetValue_pv(info.re_source, "Source", char*) ;
  2939.     if ((sv = readHash(hash, "Len")) && sv != &PL_sv_undef) {
  2940. info.re_len = SvIV(sv) ; ;
  2941. flagSet_DB2(info.flags, DB_FIXEDLEN) ;
  2942.     }
  2943.     if ((sv = readHash(hash, "Delim")) && sv != &PL_sv_undef) {
  2944. info.re_delim = SvPOK(sv) ? *SvPV(sv,PL_na) : SvIV(sv) ; ;
  2945. flagSet_DB2(info.flags, DB_DELIMITER) ;
  2946.     }
  2947.     if ((sv = readHash(hash, "Pad")) && sv != &PL_sv_undef) {
  2948. info.re_pad = (u_int32_t)SvPOK(sv) ? *SvPV(sv,PL_na) : SvIV(sv) ; ;
  2949. flagSet_DB2(info.flags, DB_PAD) ;
  2950.     }
  2951.     ZMALLOC(db, BerkeleyDB_type) ;
  2952. #ifdef ALLOW_RECNO_OFFSET
  2953.     SetValue_iv(db->array_base, "ArrayBase") ;
  2954.     db->array_base = (db->array_base == 0 ? 1 : 0) ;
  2955. #endif /* ALLOW_RECNO_OFFSET */
  2957.     RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, file, subname, DB_RECNO, flags, mode, &info) ;
  2958. }
  2959. OUTPUT:
  2960.     RETVAL
  2963. MODULE = BerkeleyDB::Queue PACKAGE = BerkeleyDB::Queue PREFIX = recno_
  2965. BerkeleyDB::Queue::Raw
  2966. _db_open_queue(self, ref)
  2967. char * self
  2968. SV *  ref
  2969. CODE:
  2970. {
  2971. #ifndef AT_LEAST_DB_3
  2972.             softCrash("BerkeleyDB::Queue needs Berkeley DB 3.0.x or better");
  2973. #else
  2974.     HV * hash ;
  2975.     SV *  sv ;
  2976.     DB_INFO  info ;
  2977.     BerkeleyDB__Env dbenv = NULL;
  2978.     SV * ref_dbenv = NULL;
  2979.     const char * file = NULL ;
  2980.     const char * subname = NULL ;
  2981.     int flags = 0 ;
  2982.     int mode = 0 ;
  2983.          BerkeleyDB  db ;
  2985.     hash = (HV*) SvRV(ref) ;
  2986.     SetValue_pv(file, "Fname", char*) ;
  2987.     SetValue_ov(dbenv, "Env", BerkeleyDB__Env) ;
  2988.     ref_dbenv = sv ;
  2989.     SetValue_iv(flags, "Flags") ;
  2990.     SetValue_iv(mode, "Mode") ;
  2992.             Zero(&info, 1, DB_INFO) ;
  2993.     SetValue_iv(info.db_cachesize, "Cachesize") ;
  2994.     SetValue_iv(info.db_lorder, "Lorder") ;
  2995.     SetValue_iv(info.db_pagesize, "Pagesize") ;
  2996.     SetValue_iv(info.bt_minkey, "Minkey") ;
  2997.          SetValue_iv(info.q_extentsize, "ExtentSize") ;
  3000.     SetValue_iv(info.flags, "Property") ;
  3001.     if ((sv = readHash(hash, "Len")) && sv != &PL_sv_undef) {
  3002. info.re_len = SvIV(sv) ; ;
  3003. flagSet_DB2(info.flags, DB_PAD) ;
  3004.     }
  3005.     if ((sv = readHash(hash, "Pad")) && sv != &PL_sv_undef) {
  3006. info.re_pad = (u_int32_t)SvPOK(sv) ? *SvPV(sv,PL_na) : SvIV(sv) ; ;
  3007. flagSet_DB2(info.flags, DB_PAD) ;
  3008.     }
  3009.     ZMALLOC(db, BerkeleyDB_type) ;
  3010. #ifdef ALLOW_RECNO_OFFSET
  3011.     SetValue_iv(db->array_base, "ArrayBase") ;
  3012.     db->array_base = (db->array_base == 0 ? 1 : 0) ;
  3013. #endif /* ALLOW_RECNO_OFFSET */
  3015.     RETVAL = my_db_open(db, ref, ref_dbenv, dbenv, file, subname, DB_QUEUE, flags, mode, &info) ;
  3016. #endif
  3017. }
  3018. OUTPUT:
  3019.     RETVAL
  3021. HV *
  3022. db_stat(db, flags=0)
  3023. BerkeleyDB::Common db
  3024. int flags
  3025. HV * RETVAL = NULL ;
  3026. INIT:
  3027.   ckActive_Database(db->active) ;
  3028. CODE:
  3029. {
  3030. #if DB_VERSION_MAJOR == 2
  3031.     softCrash("$db->db_stat for a Queue needs Berkeley DB 3.x or better") ;
  3032. #else /* Berkeley DB 3, or better */
  3033.     DB_QUEUE_STAT * stat ;
  3034.     db->Status = ((db->dbp)->stat)(db->dbp, &stat, safemalloc, flags) ;
  3035.     if (db->Status == 0) {
  3036.      RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
  3037. hv_store_iv(RETVAL, "qs_magic", stat->qs_magic) ;
  3038. hv_store_iv(RETVAL, "qs_version", stat->qs_version);
  3039. #ifdef AT_LEAST_DB_3_1
  3040. hv_store_iv(RETVAL, "qs_nkeys", stat->qs_nkeys);
  3041. hv_store_iv(RETVAL, "qs_ndata", stat->qs_ndata);
  3042. #else
  3043. hv_store_iv(RETVAL, "qs_nrecs", stat->qs_nrecs);
  3044. #endif
  3045. hv_store_iv(RETVAL, "qs_pages", stat->qs_pages);
  3046. hv_store_iv(RETVAL, "qs_pagesize", stat->qs_pagesize);
  3047. hv_store_iv(RETVAL, "qs_pgfree", stat->qs_pgfree);
  3048. hv_store_iv(RETVAL, "qs_re_len", stat->qs_re_len);
  3049. hv_store_iv(RETVAL, "qs_re_pad", stat->qs_re_pad);
  3050. #ifdef AT_LEAST_DB_3_2
  3051. #else
  3052. hv_store_iv(RETVAL, "qs_start", stat->qs_start);
  3053. #endif
  3054. hv_store_iv(RETVAL, "qs_first_recno", stat->qs_first_recno);
  3055. hv_store_iv(RETVAL, "qs_cur_recno", stat->qs_cur_recno);
  3056. #if DB_VERSION_MAJOR >= 3
  3057. hv_store_iv(RETVAL, "qs_metaflags", stat->qs_metaflags);
  3058. #endif
  3059. safefree(stat) ;
  3060.     }
  3061. #endif
  3062. }
  3063. OUTPUT:
  3064.     RETVAL
  3067. MODULE = BerkeleyDB::Common  PACKAGE = BerkeleyDB::Common PREFIX = dab_
  3070. DualType
  3071. db_close(db,flags=0)
  3072.         BerkeleyDB::Common  db
  3073. int  flags
  3074. INIT:
  3075.     ckActive_Database(db->active) ;
  3076.     CurrentDB = db ;
  3077. CODE:
  3078.     Trace(("BerkeleyDB::Common::db_close %dn", db));
  3079. #ifdef STRICT_CLOSE
  3080.     if (db->txn)
  3081. softCrash("attempted to close a database while a transaction was still open") ;
  3082.     if (db->open_cursors)
  3083. softCrash("attempted to close a database with %d open cursor(s)",
  3084. db->open_cursors) ;
  3085. #endif /* STRICT_CLOSE */
  3086.     RETVAL =  db->Status = ((db->dbp)->close)(db->dbp, flags) ;
  3087.     if (db->parent_env && db->parent_env->open_dbs)
  3088. -- db->parent_env->open_dbs ;
  3089.     db->active = FALSE ;
  3090.     hash_delete("BerkeleyDB::Term::Db", (IV)db) ;
  3091.     -- db->open_cursors ;
  3092.     Trace(("end of BerkeleyDB::Common::db_closen"));
  3093. OUTPUT:
  3094.     RETVAL
  3096. void
  3097. dab__DESTROY(db)
  3098. BerkeleyDB::Common db
  3099. CODE:
  3100.   CurrentDB = db ;
  3101.   Trace(("In BerkeleyDB::Common::_DESTROY db %d dirty=%dn", db, PL_dirty)) ;
  3102.   destroyDB(db) ;
  3103.   Trace(("End of BerkeleyDB::Common::DESTROY n")) ;
  3105. #if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
  3106. #define db_cursor(db, txn, cur,flags)  ((db->dbp)->cursor)(db->dbp, txn, cur)
  3107. #else
  3108. #define db_cursor(db, txn, cur,flags)  ((db->dbp)->cursor)(db->dbp, txn, cur,flags)
  3109. #endif
  3110. BerkeleyDB::Cursor::Raw
  3111. _db_cursor(db, flags=0)
  3112.         BerkeleyDB::Common  db
  3113. u_int32_t flags
  3114.         BerkeleyDB::Cursor  RETVAL = NULL ;
  3115. INIT:
  3116.     ckActive_Database(db->active) ;
  3117. CODE:
  3118. {
  3119.   DBC * cursor ;
  3120.   CurrentDB = db ;
  3121.   if ((db->Status = db_cursor(db, db->txn, &cursor, flags)) == 0){
  3122.       ZMALLOC(RETVAL, BerkeleyDB__Cursor_type) ;
  3123.       db->open_cursors ++ ;
  3124.       RETVAL->parent_db  = db ;
  3125.       RETVAL->cursor  = cursor ;
  3126.       RETVAL->dbp     = db->dbp ;
  3127.               RETVAL->type    = db->type ;
  3128.               RETVAL->recno_or_queue    = db->recno_or_queue ;
  3129.               RETVAL->filename    = my_strdup(db->filename) ;
  3130.               RETVAL->compare = db->compare ;
  3131.               RETVAL->dup_compare = db->dup_compare ;
  3132.               RETVAL->prefix  = db->prefix ;
  3133.               RETVAL->hash    = db->hash ;
  3134.       RETVAL->partial = db->partial ;
  3135.       RETVAL->doff    = db->doff ;
  3136.       RETVAL->dlen    = db->dlen ;
  3137.       RETVAL->active  = TRUE ;
  3138. #ifdef ALLOW_RECNO_OFFSET
  3139.       RETVAL->array_base  = db->array_base ;
  3140. #endif /* ALLOW_RECNO_OFFSET */
  3141. #ifdef DBM_FILTERING
  3142.       RETVAL->filtering   = FALSE ;
  3143.       RETVAL->filter_fetch_key    = db->filter_fetch_key ;
  3144.       RETVAL->filter_store_key    = db->filter_store_key ;
  3145.       RETVAL->filter_fetch_value  = db->filter_fetch_value ;
  3146.       RETVAL->filter_store_value  = db->filter_store_value ;
  3147. #endif
  3148.               /* RETVAL->info ; */
  3149.       hash_store_iv("BerkeleyDB::Term::Cursor", (IV)RETVAL, 1) ;
  3150.   }
  3151. }
  3152. OUTPUT:
  3153.   RETVAL
  3155. BerkeleyDB::Cursor::Raw
  3156. _db_join(db, cursors, flags=0)
  3157.         BerkeleyDB::Common  db
  3158. AV * cursors
  3159. u_int32_t flags
  3160.         BerkeleyDB::Cursor  RETVAL = NULL ;
  3161. INIT:
  3162.     ckActive_Database(db->active) ;
  3163. CODE:
  3164. {
  3165. #if DB_VERSION_MAJOR == 2 && (DB_VERSION_MINOR < 5 || (DB_VERSION_MINOR == 5 && DB_VERSION_PATCH < 2))
  3166.     softCrash("join needs Berkeley DB 2.5.2 or later") ;
  3167. #else /* Berkeley DB >= 2.5.2 */
  3168.   DBC * join_cursor ;
  3169.   DBC ** cursor_list ;
  3170.   I32 count = av_len(cursors) + 1 ;
  3171.   int i ;
  3172.   CurrentDB = db ;
  3173.   if (count < 1 )
  3174.       softCrash("db_join: No cursors in parameter list") ;
  3175.   cursor_list = (DBC **)safemalloc(sizeof(DBC*) * (count + 1));
  3176.   for (i = 0 ; i < count ; ++i) {
  3177.       SV * obj = (SV*) * av_fetch(cursors, i, FALSE) ;
  3178.       BerkeleyDB__Cursor cur = (BerkeleyDB__Cursor) getInnerObject(obj) ;
  3179.       cursor_list[i] = cur->cursor ;
  3180.   }
  3181.   cursor_list[i] = NULL ;
  3182. #if DB_VERSION_MAJOR == 2
  3183.   if ((db->Status = ((db->dbp)->join)(db->dbp, cursor_list, flags, &join_cursor)) == 0){
  3184. #else
  3185.   if ((db->Status = ((db->dbp)->join)(db->dbp, cursor_list, &join_cursor, flags)) == 0){
  3186. #endif
  3187.       ZMALLOC(RETVAL, BerkeleyDB__Cursor_type) ;
  3188.       db->open_cursors ++ ;
  3189.       RETVAL->parent_db  = db ;
  3190.       RETVAL->cursor  = join_cursor ;
  3191.       RETVAL->dbp     = db->dbp ;
  3192.               RETVAL->type    = db->type ;
  3193.               RETVAL->filename    = my_strdup(db->filename) ;
  3194.               RETVAL->compare = db->compare ;
  3195.               RETVAL->dup_compare = db->dup_compare ;
  3196.               RETVAL->prefix  = db->prefix ;
  3197.               RETVAL->hash    = db->hash ;
  3198.       RETVAL->partial = db->partial ;
  3199.       RETVAL->doff    = db->doff ;
  3200.       RETVAL->dlen    = db->dlen ;
  3201.       RETVAL->active  = TRUE ;
  3202. #ifdef ALLOW_RECNO_OFFSET
  3203.       RETVAL->array_base  = db->array_base ;
  3204. #endif /* ALLOW_RECNO_OFFSET */
  3205. #ifdef DBM_FILTERING
  3206.       RETVAL->filtering   = FALSE ;
  3207.       RETVAL->filter_fetch_key    = db->filter_fetch_key ;
  3208.       RETVAL->filter_store_key    = db->filter_store_key ;
  3209.       RETVAL->filter_fetch_value  = db->filter_fetch_value ;
  3210.       RETVAL->filter_store_value  = db->filter_store_value ;
  3211. #endif
  3212.               /* RETVAL->info ; */
  3213.       hash_store_iv("BerkeleyDB::Term::Cursor", (IV)RETVAL, 1) ;
  3214.   }
  3215.   safefree(cursor_list) ;
  3216. #endif /* Berkeley DB >= 2.5.2 */
  3217. }
  3218. OUTPUT:
  3219.   RETVAL
  3221. int
  3222. ArrayOffset(db)
  3223.         BerkeleyDB::Common  db
  3224. INIT:
  3225.     ckActive_Database(db->active) ;
  3226. CODE:
  3227. #ifdef ALLOW_RECNO_OFFSET
  3228.     RETVAL = db->array_base ? 0 : 1 ;
  3229. #else
  3230.     RETVAL = 0 ;
  3231. #endif /* ALLOW_RECNO_OFFSET */
  3232. OUTPUT:
  3233.     RETVAL
  3235. int
  3236. type(db)
  3237.         BerkeleyDB::Common  db
  3238. INIT:
  3239.     ckActive_Database(db->active) ;
  3240. CODE:
  3241.     RETVAL = db->type ;
  3242. OUTPUT:
  3243.     RETVAL
  3245. int
  3246. byteswapped(db)
  3247.         BerkeleyDB::Common  db
  3248. INIT:
  3249.     ckActive_Database(db->active) ;
  3250. CODE:
  3251. #if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 5
  3252.     softCrash("byteswapped needs Berkeley DB 2.5 or later") ;
  3253. #else
  3254. #if DB_VERSION_MAJOR == 2
  3255.     RETVAL = db->dbp->byteswapped ;
  3256. #else
  3257.     RETVAL = db->dbp->get_byteswapped(db->dbp) ;
  3258. #endif
  3259. #endif
  3260. OUTPUT:
  3261.     RETVAL
  3263. DualType
  3264. status(db)
  3265.         BerkeleyDB::Common  db
  3266. CODE:
  3267.     RETVAL =  db->Status ;
  3268. OUTPUT:
  3269.     RETVAL
  3271. #ifdef DBM_FILTERING
  3273. #define setFilter(ftype)
  3274. {
  3275.     if (db->ftype)
  3276.         RETVAL = sv_mortalcopy(db->ftype) ;
  3277.     ST(0) = RETVAL ;
  3278.     if (db->ftype && (code == &PL_sv_undef)) {
  3279.                 SvREFCNT_dec(db->ftype) ;
  3280.         db->ftype = NULL ;
  3281.     }
  3282.     else if (code) {
  3283.         if (db->ftype)
  3284.             sv_setsv(db->ftype, code) ;
  3285.         else
  3286.             db->ftype = newSVsv(code) ;
  3287.     }     
  3288. }
  3291. SV *
  3292. filter_fetch_key(db, code)
  3293. BerkeleyDB::Common db
  3294. SV * code
  3295. SV * RETVAL = &PL_sv_undef ;
  3296. CODE:
  3297.     setFilter(filter_fetch_key) ;
  3299. SV *
  3300. filter_store_key(db, code)
  3301. BerkeleyDB::Common db
  3302. SV * code
  3303. SV * RETVAL = &PL_sv_undef ;
  3304. CODE:
  3305.     setFilter(filter_store_key) ;
  3307. SV *
  3308. filter_fetch_value(db, code)
  3309. BerkeleyDB::Common db
  3310. SV * code
  3311. SV * RETVAL = &PL_sv_undef ;
  3312. CODE:
  3313.     setFilter(filter_fetch_value) ;
  3315. SV *
  3316. filter_store_value(db, code)
  3317. BerkeleyDB::Common db
  3318. SV * code
  3319. SV * RETVAL = &PL_sv_undef ;
  3320. CODE:
  3321.     setFilter(filter_store_value) ;
  3323. #endif /* DBM_FILTERING */
  3325. void
  3326. partial_set(db, offset, length)
  3327.         BerkeleyDB::Common  db
  3328. u_int32_t offset
  3329. u_int32_t length
  3330. INIT:
  3331.     ckActive_Database(db->active) ;
  3332. PPCODE:
  3333.     if (GIMME == G_ARRAY) {
  3334. XPUSHs(sv_2mortal(newSViv(db->partial == DB_DBT_PARTIAL))) ;
  3335. XPUSHs(sv_2mortal(newSViv(db->doff))) ;
  3336. XPUSHs(sv_2mortal(newSViv(db->dlen))) ;
  3337.     }
  3338.     db->partial = DB_DBT_PARTIAL ;
  3339.     db->doff    = offset ;
  3340.     db->dlen    = length ;
  3343. void
  3344. partial_clear(db)
  3345.         BerkeleyDB::Common  db
  3346. INIT:
  3347.     ckActive_Database(db->active) ;
  3348. PPCODE:
  3349.     if (GIMME == G_ARRAY) {
  3350. XPUSHs(sv_2mortal(newSViv(db->partial == DB_DBT_PARTIAL))) ;
  3351. XPUSHs(sv_2mortal(newSViv(db->doff))) ;
  3352. XPUSHs(sv_2mortal(newSViv(db->dlen))) ;
  3353.     }
  3354.     db->partial =
  3355.     db->doff    =
  3356.     db->dlen    = 0 ;
  3359. #define db_del(db, key, flags)  
  3360. (db->Status = ((db->dbp)->del)(db->dbp, db->txn, &key, flags))
  3361. DualType
  3362. db_del(db, key, flags=0)
  3363. BerkeleyDB::Common db
  3364. DBTKEY key
  3365. u_int flags
  3366. INIT:
  3367.     ckActive_Database(db->active) ;
  3368.     CurrentDB = db ;
  3371. #define db_get(db, key, data, flags)   
  3372. (db->Status = ((db->dbp)->get)(db->dbp, db->txn, &key, &data, flags))
  3373. DualType
  3374. db_get(db, key, data, flags=0)
  3375. BerkeleyDB::Common db
  3376. u_int flags
  3377. DBTKEY_B key
  3378. DBT_OPT data
  3379. INIT:
  3380.   ckActive_Database(db->active) ;
  3381.   CurrentDB = db ;
  3382.   SetPartial(data,db) ;
  3383. OUTPUT:
  3384.   key if (flagSet(DB_SET_RECNO)) OutputValue(ST(1), key) ;
  3385.   data
  3387. #define db_put(db,key,data,flag)
  3388. (db->Status = (db->dbp->put)(db->dbp,db->txn,&key,&data,flag))
  3389. DualType
  3390. db_put(db, key, data, flags=0)
  3391. BerkeleyDB::Common db
  3392. DBTKEY key
  3393. DBT data
  3394. u_int flags
  3395. INIT:
  3396.   ckActive_Database(db->active) ;
  3397.   CurrentDB = db ;
  3398.   /* SetPartial(data,db) ; */
  3399. OUTPUT:
  3400.   key if (flagSet(DB_APPEND)) OutputKey(ST(1), key) ;
  3402. #define db_key_range(db, key, range, flags)   
  3403. (db->Status = ((db->dbp)->key_range)(db->dbp, db->txn, &key, &range, flags))
  3404. DualType
  3405. db_key_range(db, key, less, equal, greater, flags=0)
  3406. BerkeleyDB::Common db
  3407. DBTKEY_B key
  3408. double          less = NO_INIT
  3409. double          equal = NO_INIT
  3410. double          greater = NO_INIT
  3411. u_int32_t flags
  3412. CODE:
  3413. {
  3414. #ifndef AT_LEAST_DB_3_1
  3415.           softCrash("key_range needs Berkeley DB 3.1.x or later") ;
  3416. #else
  3417.           DB_KEY_RANGE range ;
  3418.           range.less = range.equal = range.greater = 0.0 ;
  3419.   ckActive_Database(db->active) ;
  3420.   CurrentDB = db ;
  3421.   RETVAL = db_key_range(db, key, range, flags);
  3422.   if (RETVAL == 0) {
  3423.         less = range.less ;
  3424.         equal = range.equal;
  3425.         greater = range.greater;
  3426.   }
  3427. #endif
  3428. }
  3429. OUTPUT:
  3430.   RETVAL
  3431.   less
  3432.   equal
  3433.   greater
  3436. #define db_fd(d, x) (db->Status = (db->dbp->fd)(db->dbp, &x))
  3437. DualType
  3438. db_fd(db)
  3439. BerkeleyDB::Common db
  3440. INIT:
  3441.   ckActive_Database(db->active) ;
  3442. CODE:
  3443.   CurrentDB = db ;
  3444.   db_fd(db, RETVAL) ;
  3445. OUTPUT:
  3446.   RETVAL
  3449. #define db_sync(db, fl) (db->Status = (db->dbp->sync)(db->dbp, fl))
  3450. DualType
  3451. db_sync(db, flags=0)
  3452. BerkeleyDB::Common db
  3453. u_int flags
  3454. INIT:
  3455.   ckActive_Database(db->active) ;
  3456.   CurrentDB = db ;
  3458. void
  3459. _Txn(db, txn=NULL)
  3460.         BerkeleyDB::Common      db
  3461.         BerkeleyDB::Txn         txn
  3462. INIT:
  3463.   ckActive_Database(db->active) ;
  3464. CODE:
  3465.    if (txn) {
  3466.        Trace(("_Txn(%d in %d) active [%d]n", txn->txn, txn, txn->active));
  3467.        ckActive_Transaction(txn->active) ;
  3468.        db->txn = txn->txn ;
  3469.    }
  3470.    else {
  3471.        Trace(("_Txn(undef) n"));
  3472.        db->txn = NULL ;
  3473.    }
  3478. MODULE = BerkeleyDB::Cursor              PACKAGE = BerkeleyDB::Cursor PREFIX = cu_
  3480. BerkeleyDB::Cursor::Raw
  3481. _c_dup(db, flags=0)
  3482.      BerkeleyDB::Cursor db
  3483. u_int32_t flags
  3484.         BerkeleyDB::Cursor  RETVAL = NULL ;
  3485. INIT:
  3486.     CurrentDB = db->parent_db ;
  3487.     ckActive_Database(db->active) ;
  3488. CODE:
  3489. {
  3490. #ifndef AT_LEAST_DB_3
  3491.           softCrash("c_dup needs at least Berkeley DB 3.0.x");
  3492. #else
  3493.   DBC * newcursor ;
  3494.   db->Status = ((db->cursor)->c_dup)(db->cursor, &newcursor, flags) ;
  3495.   if (db->Status == 0){
  3496.       ZMALLOC(RETVAL, BerkeleyDB__Cursor_type) ;
  3497.       db->parent_db->open_cursors ++ ;
  3498.       RETVAL->parent_db  = db->parent_db ;
  3499.       RETVAL->cursor  = newcursor ;
  3500.       RETVAL->dbp     = db->dbp ;
  3501.               RETVAL->type    = db->type ;
  3502.               RETVAL->recno_or_queue    = db->recno_or_queue ;
  3503.               RETVAL->filename    = my_strdup(db->filename) ;
  3504.               RETVAL->compare = db->compare ;
  3505.               RETVAL->dup_compare = db->dup_compare ;
  3506.               RETVAL->prefix  = db->prefix ;
  3507.               RETVAL->hash    = db->hash ;
  3508.       RETVAL->partial = db->partial ;
  3509.       RETVAL->doff    = db->doff ;
  3510.       RETVAL->dlen    = db->dlen ;
  3511.       RETVAL->active  = TRUE ;
  3512. #ifdef ALLOW_RECNO_OFFSET
  3513.       RETVAL->array_base  = db->array_base ;
  3514. #endif /* ALLOW_RECNO_OFFSET */
  3515. #ifdef DBM_FILTERING
  3516.       RETVAL->filtering   = FALSE ;
  3517.       RETVAL->filter_fetch_key    = db->filter_fetch_key ;
  3518.       RETVAL->filter_store_key    = db->filter_store_key ;
  3519.       RETVAL->filter_fetch_value  = db->filter_fetch_value ;
  3520.       RETVAL->filter_store_value  = db->filter_store_value ;
  3521. #endif /* DBM_FILTERING */
  3522.               /* RETVAL->info ; */
  3523.       hash_store_iv("BerkeleyDB::Term::Cursor", (IV)RETVAL, 1) ;
  3524.   }
  3525. #endif
  3526. }
  3527. OUTPUT:
  3528.   RETVAL
  3530. DualType
  3531. _c_close(db)
  3532.     BerkeleyDB::Cursor db
  3533. INIT:
  3534.   CurrentDB = db->parent_db ;
  3535.   ckActive_Cursor(db->active) ;
  3536.   hash_delete("BerkeleyDB::Term::Cursor", (IV)db) ;
  3537. CODE:
  3538.   RETVAL =  db->Status =
  3539.                ((db->cursor)->c_close)(db->cursor) ;
  3540.   db->active = FALSE ;
  3541.   if (db->parent_db->open_cursors)
  3542.       -- db->parent_db->open_cursors ;
  3543. OUTPUT:
  3544.   RETVAL
  3546. void
  3547. _DESTROY(db)
  3548.     BerkeleyDB::Cursor db
  3549. CODE:
  3550.   CurrentDB = db->parent_db ;
  3551.   Trace(("In BerkeleyDB::Cursor::_DESTROY db %d dirty=%d active=%dn", db, PL_dirty, db->active));
  3552.   hash_delete("BerkeleyDB::Term::Cursor", (IV)db) ;
  3553.   if (db->active)
  3554.            ((db->cursor)->c_close)(db->cursor) ;
  3555.   if (db->parent_db->open_cursors)
  3556.       -- db->parent_db->open_cursors ;
  3557.           Safefree(db->filename) ;
  3558.           Safefree(db) ;
  3559.   Trace(("End of BerkeleyDB::Cursor::_DESTROYn")) ;
  3561. DualType
  3562. status(db)
  3563.         BerkeleyDB::Cursor  db
  3564. CODE:
  3565.     RETVAL =  db->Status ;
  3566. OUTPUT:
  3567.     RETVAL
  3570. #define cu_c_del(c,f) (c->Status = ((c->cursor)->c_del)(c->cursor,f))
  3571. DualType
  3572. cu_c_del(db, flags=0)
  3573.     BerkeleyDB::Cursor db
  3574.     int flags
  3575. INIT:
  3576.   CurrentDB = db->parent_db ;
  3577.   ckActive_Cursor(db->active) ;
  3578. OUTPUT:
  3579.   RETVAL
  3582. #define cu_c_get(c,k,d,f) (c->Status = (c->cursor->c_get)(c->cursor,&k,&d,f))
  3583. DualType
  3584. cu_c_get(db, key, data, flags=0)
  3585.     BerkeleyDB::Cursor db
  3586.     int flags
  3587.     DBTKEY_B key
  3588.     DBT_B data
  3589. INIT:
  3590.   Trace(("c_get db [%d] flags [%d]n", db, flags)) ;
  3591.   CurrentDB = db->parent_db ;
  3592.   ckActive_Cursor(db->active) ;
  3593.   SetPartial(data,db) ;
  3594.   Trace(("c_get endn")) ;
  3595. OUTPUT:
  3596.   RETVAL
  3597.   key
  3598.   data if (! flagSet(DB_JOIN_ITEM)) OutputValue_B(ST(2), data) ;
  3601. #define cu_c_put(c,k,d,f)  (c->Status = (c->cursor->c_put)(c->cursor,&k,&d,f))
  3602. DualType
  3603. cu_c_put(db, key, data, flags=0)
  3604.     BerkeleyDB::Cursor db
  3605.     DBTKEY key
  3606.     DBT data
  3607.     int flags
  3608. INIT:
  3609.   CurrentDB = db->parent_db ;
  3610.   ckActive_Cursor(db->active) ;
  3611.   /* SetPartial(data,db) ; */
  3612. OUTPUT:
  3613.   RETVAL
  3615. #define cu_c_count(c,p,f) (c->Status = (c->cursor->c_count)(c->cursor,&p,f))
  3616. DualType
  3617. cu_c_count(db, count, flags=0)
  3618.     BerkeleyDB::Cursor db
  3619.     u_int32_t           count = NO_INIT
  3620.     int flags
  3621. CODE:
  3622. #ifndef AT_LEAST_DB_3_1
  3623.           softCrash("c_count needs at least Berkeley DB 3.1.x");
  3624. #else
  3625.   Trace(("c_get count [%d] flags [%d]n", db, flags)) ;
  3626.   CurrentDB = db->parent_db ;
  3627.   ckActive_Cursor(db->active) ;
  3628.   RETVAL = cu_c_count(db, count, flags) ;
  3629.   Trace(("    c_count got %d duplicatesn", count)) ;
  3630. #endif
  3631. OUTPUT:
  3632.   RETVAL
  3633.   count
  3635. MODULE = BerkeleyDB::TxnMgr           PACKAGE = BerkeleyDB::TxnMgr PREFIX = xx_
  3637. BerkeleyDB::Txn::Raw
  3638. _txn_begin(txnmgr, pid=NULL, flags=0)
  3639. BerkeleyDB::TxnMgr txnmgr
  3640. BerkeleyDB::Txn pid
  3641. u_int32_t flags
  3642. CODE:
  3643. {
  3644.     DB_TXN *txn ;
  3645.     DB_TXN *p_id = NULL ;
  3646. #if DB_VERSION_MAJOR == 2
  3647.     if (txnmgr->env->Env->tx_info == NULL)
  3648. softCrash("Transaction Manager not enabled") ;
  3649. #endif
  3650.     if (pid)
  3651. p_id = pid->txn ;
  3652.     txnmgr->env->TxnMgrStatus =
  3653. #if DB_VERSION_MAJOR == 2
  3654.      txn_begin(txnmgr->env->Env->tx_info, p_id, &txn) ;
  3655. #else
  3656.      txn_begin(txnmgr->env->Env, p_id, &txn, flags) ;
  3657. #endif
  3658.     if (txnmgr->env->TxnMgrStatus == 0) {
  3659.       ZMALLOC(RETVAL, BerkeleyDB_Txn_type) ;
  3660.       RETVAL->txn  = txn ;
  3661.       RETVAL->active = TRUE ;
  3662.       Trace(("_txn_begin created txn [%d] in [%d]n", txn, RETVAL));
  3663.       hash_store_iv("BerkeleyDB::Term::Txn", (IV)RETVAL, 1) ;
  3664.     }
  3665.     else
  3666. RETVAL = NULL ;
  3667. }
  3668. OUTPUT:
  3669.     RETVAL
  3672. DualType
  3673. status(mgr)
  3674.         BerkeleyDB::TxnMgr  mgr
  3675. CODE:
  3676.     RETVAL =  mgr->env->TxnMgrStatus ;
  3677. OUTPUT:
  3678.     RETVAL
  3681. void
  3682. _DESTROY(mgr)
  3683.     BerkeleyDB::TxnMgr mgr
  3684. CODE:
  3685.   Trace(("In BerkeleyDB::TxnMgr::DESTROY dirty=%dn", PL_dirty)) ;
  3686.           Safefree(mgr) ;
  3687.   Trace(("End of BerkeleyDB::TxnMgr::DESTROYn")) ;
  3689. DualType
  3690. txn_close(txnp)
  3691. BerkeleyDB::TxnMgr txnp
  3692.         NOT_IMPLEMENTED_YET
  3695. #if DB_VERSION_MAJOR == 2
  3696. #  define xx_txn_checkpoint(t,k,m) txn_checkpoint(t->env->Env->tx_info, k, m)
  3697. #else
  3698. #  ifdef AT_LEAST_DB_3_1
  3699. #    define xx_txn_checkpoint(t,k,m) txn_checkpoint(t->env->Env, k, m, 0)
  3700. #  else
  3701. #    define xx_txn_checkpoint(t,k,m) txn_checkpoint(t->env->Env, k, m)
  3702. #  endif
  3703. #endif
  3704. DualType
  3705. xx_txn_checkpoint(txnp, kbyte, min)
  3706. BerkeleyDB::TxnMgr txnp
  3707. long kbyte
  3708. long min
  3710. HV *
  3711. txn_stat(txnp)
  3712. BerkeleyDB::TxnMgr txnp
  3713. HV * RETVAL = NULL ;
  3714. CODE:
  3715. {
  3716.     DB_TXN_STAT * stat ;
  3717. #if DB_VERSION_MAJOR == 2
  3718.     if(txn_stat(txnp->env->Env->tx_info, &stat, safemalloc) == 0) {
  3719. #else
  3720.     if(txn_stat(txnp->env->Env, &stat, safemalloc) == 0) {
  3721. #endif
  3722.      RETVAL = (HV*)sv_2mortal((SV*)newHV()) ;
  3723. hv_store_iv(RETVAL, "st_time_ckp", stat->st_time_ckp) ;
  3724. hv_store_iv(RETVAL, "st_last_txnid", stat->st_last_txnid) ;
  3725. hv_store_iv(RETVAL, "st_maxtxns", stat->st_maxtxns) ;
  3726. hv_store_iv(RETVAL, "st_naborts", stat->st_naborts) ;
  3727. hv_store_iv(RETVAL, "st_nbegins", stat->st_nbegins) ;
  3728. hv_store_iv(RETVAL, "st_ncommits", stat->st_ncommits) ;
  3729. hv_store_iv(RETVAL, "st_nactive", stat->st_nactive) ;
  3730. #if DB_VERSION_MAJOR > 2
  3731. hv_store_iv(RETVAL, "st_maxnactive", stat->st_maxnactive) ;
  3732. hv_store_iv(RETVAL, "st_regsize", stat->st_regsize) ;
  3733. hv_store_iv(RETVAL, "st_region_wait", stat->st_region_wait) ;
  3734. hv_store_iv(RETVAL, "st_region_nowait", stat->st_region_nowait) ;
  3735. #endif
  3736. safefree(stat) ;
  3737.     }
  3738. }
  3739. OUTPUT:
  3740.     RETVAL
  3743. BerkeleyDB::TxnMgr
  3744. txn_open(dir, flags, mode, dbenv)
  3745.     const char * dir
  3746.     int  flags
  3747.     int  mode
  3748.     BerkeleyDB::Env  dbenv
  3749.         NOT_IMPLEMENTED_YET
  3752. MODULE = BerkeleyDB::Txn              PACKAGE = BerkeleyDB::Txn PREFIX = xx_
  3754. DualType
  3755. status(tid)
  3756.         BerkeleyDB::Txn  tid
  3757. CODE:
  3758.     RETVAL =  tid->Status ;
  3759. OUTPUT:
  3760.     RETVAL
  3762. int
  3763. _DESTROY(tid)
  3764.     BerkeleyDB::Txn tid
  3765. CODE:
  3766.   Trace(("In BerkeleyDB::Txn::_DESTROY txn [%d] active [%d] dirty=%dn", tid->txn, tid->active, PL_dirty)) ;
  3767.   if (tid->active)
  3768.     txn_abort(tid->txn) ;
  3769.           RETVAL = (int)tid ;
  3770.   hash_delete("BerkeleyDB::Term::Txn", (IV)tid) ;
  3771.           Safefree(tid) ;
  3772.   Trace(("End of BerkeleyDB::Txn::DESTROYn")) ;
  3773. OUTPUT:
  3774.   RETVAL
  3776. #define xx_txn_unlink(d,f,e) txn_unlink(d,f,&(e->Env))
  3777. DualType
  3778. xx_txn_unlink(dir, force, dbenv)
  3779.     const char * dir
  3780.     int  force
  3781.     BerkeleyDB::Env  dbenv
  3782.         NOT_IMPLEMENTED_YET
  3784. #define xx_txn_prepare(t) (t->Status = txn_prepare(t->txn))
  3785. DualType
  3786. xx_txn_prepare(tid)
  3787. BerkeleyDB::Txn tid
  3788. INIT:
  3789.     ckActive_Transaction(tid->active) ;
  3791. #if DB_VERSION_MAJOR == 2
  3792. #  define _txn_commit(t,flags) (t->Status = txn_commit(t->txn))
  3793. #else
  3794. #  define _txn_commit(t, flags) (t->Status = txn_commit(t->txn, flags))
  3795. #endif
  3796. DualType
  3797. _txn_commit(tid, flags=0)
  3798. BerkeleyDB::Txn tid
  3799. u_int32_t flags
  3800. INIT:
  3801.     ckActive_Transaction(tid->active) ;
  3802.     hash_delete("BerkeleyDB::Term::Txn", (IV)tid) ;
  3803.     tid->active = FALSE ;
  3805. #define _txn_abort(t) (t->Status = txn_abort(t->txn))
  3806. DualType
  3807. _txn_abort(tid)
  3808. BerkeleyDB::Txn tid
  3809. INIT:
  3810.     ckActive_Transaction(tid->active) ;
  3811.     hash_delete("BerkeleyDB::Term::Txn", (IV)tid) ;
  3812.     tid->active = FALSE ;
  3814. #define xx_txn_id(t) txn_id(t->txn)
  3815. u_int32_t
  3816. xx_txn_id(tid)
  3817. BerkeleyDB::Txn tid
  3819. MODULE = BerkeleyDB::_tiedHash        PACKAGE = BerkeleyDB::_tiedHash
  3821. int
  3822. FIRSTKEY(db)
  3823.         BerkeleyDB::Common         db
  3824.         CODE:
  3825.         {
  3826.             DBTKEY      key ;
  3827.             DBT         value ;
  3828.     DBC * cursor ;
  3830.     /*
  3831. TODO!
  3832. set partial value to 0 - to eliminate the retrieval of
  3833. the value need to store any existing partial settings &
  3834. restore at the end.
  3836.      */
  3837.             CurrentDB = db ;
  3838.     DBT_clear(key) ;
  3839.     DBT_clear(value) ;
  3840.     /* If necessary create a cursor for FIRSTKEY/NEXTKEY use */
  3841.     if (!db->cursor &&
  3842. (db->Status = db_cursor(db, db->txn, &cursor, 0)) == 0 )
  3843.             db->cursor  = cursor ;
  3845.     if (db->cursor)
  3846.         RETVAL = (db->Status) =
  3847.     ((db->cursor)->c_get)(db->cursor, &key, &value, DB_FIRST);
  3848.     else
  3849. RETVAL = db->Status ;
  3850.     /* check for end of cursor */
  3851.     if (RETVAL == DB_NOTFOUND) {
  3852.       ((db->cursor)->c_close)(db->cursor) ;
  3853.       db->cursor = NULL ;
  3854.     }
  3855.             ST(0) = sv_newmortal();
  3856.     OutputKey(ST(0), key)
  3857.         }
  3861. int
  3862. NEXTKEY(db, key)
  3863.         BerkeleyDB::Common  db
  3864.         DBTKEY              key
  3865.         CODE:
  3866.         {
  3867.             DBT         value ;
  3869.             CurrentDB = db ;
  3870.     DBT_clear(value) ;
  3871.     key.flags = 0 ;
  3872.     RETVAL = (db->Status) =
  3873. ((db->cursor)->c_get)(db->cursor, &key, &value, DB_NEXT);
  3875.     /* check for end of cursor */
  3876.     if (RETVAL == DB_NOTFOUND) {
  3877.       ((db->cursor)->c_close)(db->cursor) ;
  3878.       db->cursor = NULL ;
  3879.     }
  3880.             ST(0) = sv_newmortal();
  3881.     OutputKey(ST(0), key)
  3882.         }
  3884. MODULE = BerkeleyDB::_tiedArray        PACKAGE = BerkeleyDB::_tiedArray
  3886. I32
  3887. FETCHSIZE(db)
  3888.         BerkeleyDB::Common         db
  3889.         CODE:
  3890.             CurrentDB = db ;
  3891.             RETVAL = GetArrayLength(db) ;
  3892.         OUTPUT:
  3893.             RETVAL
  3896. MODULE = BerkeleyDB        PACKAGE = BerkeleyDB
  3898. BOOT:
  3899.   {
  3900.     SV * sv_err = perl_get_sv(ERR_BUFF, GV_ADD|GV_ADDMULTI) ;
  3901.     SV * version_sv = perl_get_sv("BerkeleyDB::db_version", GV_ADD|GV_ADDMULTI) ;
  3902.     SV * ver_sv = perl_get_sv("BerkeleyDB::db_ver", GV_ADD|GV_ADDMULTI) ;
  3903.     int Major, Minor, Patch ;
  3904.     (void)db_version(&Major, &Minor, &Patch) ;
  3905.     /* Check that the versions of db.h and libdb.a are the same */
  3906.     if (Major != DB_VERSION_MAJOR || Minor != DB_VERSION_MINOR
  3907.                 || Patch != DB_VERSION_PATCH)
  3908.         croak("nBerkeleyDB needs compatible versions of libdb & db.hntyou have db.h version %d.%d.%d and libdb version %d.%d.%dn",
  3909.                 DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH,
  3910.                 Major, Minor, Patch) ;
  3912.     if (Major < 2 || (Major == 2 && Minor < 6))
  3913.     {
  3914.         croak("BerkeleyDB needs Berkeley DB 2.6 or greater. This is %d.%d.%dn",
  3915. Major, Minor, Patch) ;
  3916.     }
  3917.     sv_setpvf(version_sv, "%d.%d", Major, Minor) ;
  3918.     sv_setpvf(ver_sv, "%d.%03d%03d", Major, Minor, Patch) ;
  3919.     sv_setpv(sv_err, "");
  3921.     DBT_clear(empty) ;
  3922.     empty.data  = &zero ;
  3923.     empty.size  =  sizeof(db_recno_t) ;
  3924.     empty.flags = 0 ;
  3926.   }