ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/BDB/BDB.xs
(Generate patch)

Comparing BDB/BDB.xs (file contents):
Revision 1.6 by root, Tue Feb 6 01:09:04 2007 UTC vs.
Revision 1.11 by root, Wed May 9 06:42:24 2007 UTC

1/* solaris */ 1#include "xthread.h"
2#define _POSIX_PTHREAD_SEMANTICS 1
3
4#if __linux && !defined(_GNU_SOURCE)
5# define _GNU_SOURCE
6#endif
7
8/* just in case */
9#define _REENTRANT 1
10 2
11#include <errno.h> 3#include <errno.h>
12 4
13#include "EXTERN.h" 5#include "EXTERN.h"
14#include "perl.h" 6#include "perl.h"
15#include "XSUB.h" 7#include "XSUB.h"
16
17#include <pthread.h>
18 8
19#include <stddef.h> 9#include <stddef.h>
20#include <stdlib.h> 10#include <stdlib.h>
21#include <errno.h> 11#include <errno.h>
22#include <sys/time.h> 12#include <sys/time.h>
… …
25#include <unistd.h> 15#include <unistd.h>
26#include <fcntl.h> 16#include <fcntl.h>
27 17
28#include <db.h> 18#include <db.h>
29 19
20#if DB_VERSION_MAJOR < 4 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR < 5)
21# error you need Berkeley DB 4.5 or newer installed
22#endif
23
30/* number of seconds after which idle threads exit */ 24/* number of seconds after which idle threads exit */
31#define IDLE_TIMEOUT 10 25#define IDLE_TIMEOUT 10
32 26
33/* wether word reads are potentially non-atomic.
34 * this is conservatice, likely most arches this runs
35 * on have atomic word read/writes.
36 */
37#ifndef WORDACCESS_UNSAFE
38# if __i386 || __x86_64
39# define WORDACCESS_UNSAFE 0
40# else
41# define WORDACCESS_UNSAFE 1
42# endif
43#endif
44
45typedef DB_ENV DB_ENV_ornull; 27typedef DB_ENV DB_ENV_ornull;
46typedef DB_TXN DB_TXN_ornull; 28typedef DB_TXN DB_TXN_ornull;
47typedef DBC DBC_ornull; 29typedef DBC DBC_ornull;
48typedef DB DB_ornull; 30typedef DB DB_ornull;
31typedef DB_SEQUENCE DB_SEQUENCE_ornull;
49 32
50typedef SV SV8; /* byte-sv, used for argument-checking */ 33typedef SV SV8; /* byte-sv, used for argument-checking */
51typedef char *octetstring; 34typedef char *octetstring;
52 35
53static SV *prepare_cb; 36static SV *prepare_cb;
… …
83 free (dbt->data); 66 free (dbt->data);
84} 67}
85 68
86enum { 69enum {
87 REQ_QUIT, 70 REQ_QUIT,
88 REQ_ENV_OPEN, REQ_ENV_CLOSE, 71 REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT,
89 REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, 72 REQ_ENV_MEMP_SYNC, REQ_ENV_MEMP_TRICKLE,
73 REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC,
74 REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, REQ_DB_KEY_RANGE,
90 REQ_TXN_COMMIT, REQ_TXN_ABORT, 75 REQ_TXN_COMMIT, REQ_TXN_ABORT,
91 REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL, 76 REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL,
77 REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE,
92}; 78};
93 79
94typedef struct aio_cb 80typedef struct aio_cb
95{ 81{
96 struct aio_cb *volatile next; 82 struct aio_cb *volatile next;
… …
107 U32 uint1, uint2; 93 U32 uint1, uint2;
108 char *buf1, *buf2; 94 char *buf1, *buf2;
109 SV *sv1, *sv2, *sv3; 95 SV *sv1, *sv2, *sv3;
110 96
111 DBT dbt1, dbt2, dbt3; 97 DBT dbt1, dbt2, dbt3;
98 DB_KEY_RANGE key_range;
99 DB_SEQUENCE *seq;
100 db_seq_t seq_t;
112} aio_cb; 101} aio_cb;
113 102
114typedef aio_cb *aio_req; 103typedef aio_cb *aio_req;
115 104
116enum { 105enum {
… …
136 125
137static int next_pri = DEFAULT_PRI + PRI_BIAS; 126static int next_pri = DEFAULT_PRI + PRI_BIAS;
138 127
139static unsigned int started, idle, wanted; 128static unsigned int started, idle, wanted;
140 129
141#if __linux && defined (PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP)
142# define AIO_MUTEX_INIT PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
143#else
144# define AIO_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
145#endif
146
147#define LOCK(mutex) pthread_mutex_lock (&(mutex))
148#define UNLOCK(mutex) pthread_mutex_unlock (&(mutex))
149
150/* worker threads management */ 130/* worker threads management */
151static pthread_mutex_t wrklock = AIO_MUTEX_INIT; 131static mutex_t wrklock = MUTEX_INIT;
152 132
153typedef struct worker { 133typedef struct worker {
154 /* locked by wrklock */ 134 /* locked by wrklock */
155 struct worker *prev, *next; 135 struct worker *prev, *next;
156 136
157 pthread_t tid; 137 thread_t tid;
158 138
159 /* locked by reslock, reqlock or wrklock */ 139 /* locked by reslock, reqlock or wrklock */
160 aio_req req; /* currently processed request */ 140 aio_req req; /* currently processed request */
161 void *dbuf; 141 void *dbuf;
162 DIR *dirp; 142 DIR *dirp;
… …
179static volatile unsigned int nreqs, nready, npending; 159static volatile unsigned int nreqs, nready, npending;
180static volatile unsigned int max_idle = 4; 160static volatile unsigned int max_idle = 4;
181static volatile unsigned int max_outstanding = 0xffffffff; 161static volatile unsigned int max_outstanding = 0xffffffff;
182static int respipe [2]; 162static int respipe [2];
183 163
184static pthread_mutex_t reslock = AIO_MUTEX_INIT; 164static mutex_t reslock = MUTEX_INIT;
185static pthread_mutex_t reqlock = AIO_MUTEX_INIT; 165static mutex_t reqlock = MUTEX_INIT;
186static pthread_cond_t reqwait = PTHREAD_COND_INITIALIZER; 166static cond_t reqwait = COND_INIT;
187 167
188#if WORDACCESS_UNSAFE 168#if WORDACCESS_UNSAFE
189 169
190static unsigned int get_nready () 170static unsigned int get_nready ()
191{ 171{
… …
293 if (SvOK (req->callback)) 273 if (SvOK (req->callback))
294 { 274 {
295 ENTER; 275 ENTER;
296 SAVETMPS; 276 SAVETMPS;
297 PUSHMARK (SP); 277 PUSHMARK (SP);
298 EXTEND (SP, 1);
299 278
300 switch (req->type) 279 switch (req->type)
301 { 280 {
302 case REQ_DB_CLOSE: 281 case REQ_DB_CLOSE:
303 SvREFCNT_dec (req->sv1); 282 SvREFCNT_dec (req->sv1);
… …
312 case REQ_C_PGET: 291 case REQ_C_PGET:
313 dbt_to_sv (req->sv1, &req->dbt1); 292 dbt_to_sv (req->sv1, &req->dbt1);
314 dbt_to_sv (req->sv2, &req->dbt2); 293 dbt_to_sv (req->sv2, &req->dbt2);
315 dbt_to_sv (req->sv3, &req->dbt3); 294 dbt_to_sv (req->sv3, &req->dbt3);
316 break; 295 break;
296
297 case REQ_DB_KEY_RANGE:
298 {
299 AV *av = newAV ();
300
301 av_push (av, newSVnv (req->key_range.less));
302 av_push (av, newSVnv (req->key_range.equal));
303 av_push (av, newSVnv (req->key_range.greater));
304
305 SvREADONLY_off (req->sv1);
306 sv_setsv_mg (req->sv1, newRV_noinc ((SV *)av));
307 SvREFCNT_dec (req->sv1);
308 }
309 break;
310
311 case REQ_SEQ_GET:
312 SvREADONLY_off (req->sv1);
313
314 if (sizeof (IV) > 4)
315 sv_setiv_mg (req->sv1, req->seq_t);
316 else
317 sv_setnv_mg (req->sv1, req->seq_t);
318
319 SvREFCNT_dec (req->sv1);
320 break;
317 } 321 }
318 322
319 errno = req->result; 323 errno = req->result;
320 324
321 PUTBACK; 325 PUTBACK;
… …
338 342
339static void *aio_proc (void *arg); 343static void *aio_proc (void *arg);
340 344
341static void start_thread (void) 345static void start_thread (void)
342{ 346{
343 sigset_t fullsigset, oldsigset;
344 pthread_attr_t attr;
345
346 worker *wrk = calloc (1, sizeof (worker)); 347 worker *wrk = calloc (1, sizeof (worker));
347 348
348 if (!wrk) 349 if (!wrk)
349 croak ("unable to allocate worker thread data"); 350 croak ("unable to allocate worker thread data");
350 351
351 pthread_attr_init (&attr);
352 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
353#ifdef PTHREAD_SCOPE_PROCESS
354 pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
355#endif
356
357 sigfillset (&fullsigset);
358
359 LOCK (wrklock); 352 LOCK (wrklock);
360 pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
361
362 if (pthread_create (&wrk->tid, &attr, aio_proc, (void *)wrk) == 0) 353 if (thread_create (&wrk->tid, aio_proc, (void *)wrk))
363 { 354 {
364 wrk->prev = &wrk_first; 355 wrk->prev = &wrk_first;
365 wrk->next = wrk_first.next; 356 wrk->next = wrk_first.next;
366 wrk_first.next->prev = wrk; 357 wrk_first.next->prev = wrk;
367 wrk_first.next = wrk; 358 wrk_first.next = wrk;
368 ++started; 359 ++started;
369 } 360 }
370 else 361 else
371 free (wrk); 362 free (wrk);
372 363
373 pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
374 UNLOCK (wrklock); 364 UNLOCK (wrklock);
375} 365}
376 366
377static void maybe_start_thread () 367static void maybe_start_thread ()
378{ 368{
… …
410 ++nreqs; 400 ++nreqs;
411 401
412 LOCK (reqlock); 402 LOCK (reqlock);
413 ++nready; 403 ++nready;
414 reqq_push (&req_queue, req); 404 reqq_push (&req_queue, req);
415 pthread_cond_signal (&reqwait); 405 COND_SIGNAL (reqwait);
416 UNLOCK (reqlock); 406 UNLOCK (reqlock);
417 407
418 maybe_start_thread (); 408 maybe_start_thread ();
419 409
420 if (wait_callback) 410 if (wait_callback)
… …
436 req->type = REQ_QUIT; 426 req->type = REQ_QUIT;
437 req->pri = PRI_MAX + PRI_BIAS; 427 req->pri = PRI_MAX + PRI_BIAS;
438 428
439 LOCK (reqlock); 429 LOCK (reqlock);
440 reqq_push (&req_queue, req); 430 reqq_push (&req_queue, req);
441 pthread_cond_signal (&reqwait); 431 COND_SIGNAL (reqwait);
442 UNLOCK (reqlock); 432 UNLOCK (reqlock);
443 433
444 LOCK (wrklock); 434 LOCK (wrklock);
445 --started; 435 --started;
446 UNLOCK (wrklock); 436 UNLOCK (wrklock);
… …
602 if (req) 592 if (req)
603 break; 593 break;
604 594
605 ++idle; 595 ++idle;
606 596
607 if (pthread_cond_timedwait (&reqwait, &reqlock, &ts) 597 if (COND_TIMEDWAIT (reqwait, reqlock, ts)
608 == ETIMEDOUT) 598 == ETIMEDOUT)
609 { 599 {
610 if (idle > max_idle) 600 if (idle > max_idle)
611 { 601 {
612 --idle; 602 --idle;
… …
616 UNLOCK (wrklock); 606 UNLOCK (wrklock);
617 goto quit; 607 goto quit;
618 } 608 }
619 609
620 /* we are allowed to idle, so do so without any timeout */ 610 /* we are allowed to idle, so do so without any timeout */
621 pthread_cond_wait (&reqwait, &reqlock); 611 COND_WAIT (reqwait, reqlock);
622 ts.tv_sec = time (0) + IDLE_TIMEOUT; 612 ts.tv_sec = time (0) + IDLE_TIMEOUT;
623 } 613 }
624 614
625 --idle; 615 --idle;
626 } 616 }
… …
640 630
641 case REQ_ENV_CLOSE: 631 case REQ_ENV_CLOSE:
642 req->result = req->env->close (req->env, req->uint1); 632 req->result = req->env->close (req->env, req->uint1);
643 break; 633 break;
644 634
635 case REQ_ENV_TXN_CHECKPOINT:
636 req->result = req->env->txn_checkpoint (req->env, req->uint1, req->int1, req->uint2);
637 break;
638
639 case REQ_ENV_LOCK_DETECT:
640 req->result = req->env->lock_detect (req->env, req->uint1, req->uint2, &req->int1);
641 break;
642
643 case REQ_ENV_MEMP_SYNC:
644 req->result = req->env->memp_sync (req->env, 0);
645 break;
646
647 case REQ_ENV_MEMP_TRICKLE:
648 req->result = req->env->memp_trickle (req->env, req->int1, &req->int2);
649 break;
650
645 case REQ_DB_OPEN: 651 case REQ_DB_OPEN:
646 req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2); 652 req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
647 break; 653 break;
648 654
649 case REQ_DB_CLOSE: 655 case REQ_DB_CLOSE:
… …
670 req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1); 676 req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
671 break; 677 break;
672 678
673 case REQ_DB_DEL: 679 case REQ_DB_DEL:
674 req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1); 680 req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);
681 break;
682
683 case REQ_DB_KEY_RANGE:
684 req->result = req->db->key_range (req->db, req->txn, &req->dbt1, &req->key_range, req->uint1);
675 break; 685 break;
676 686
677 case REQ_TXN_COMMIT: 687 case REQ_TXN_COMMIT:
678 req->result = req->txn->commit (req->txn, req->uint1); 688 req->result = req->txn->commit (req->txn, req->uint1);
679 break; 689 break;
… …
706 req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1); 716 req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
707 break; 717 break;
708 718
709 case REQ_C_DEL: 719 case REQ_C_DEL:
710 req->result = req->dbc->c_del (req->dbc, req->uint1); 720 req->result = req->dbc->c_del (req->dbc, req->uint1);
721 break;
722
723 case REQ_SEQ_OPEN:
724 req->result = req->seq->open (req->seq, req->txn, &req->dbt1, req->uint1);
725 break;
726
727 case REQ_SEQ_CLOSE:
728 req->result = req->seq->close (req->seq, req->uint1);
729 break;
730
731 case REQ_SEQ_GET:
732 req->result = req->seq->get (req->seq, req->txn, req->int1, &req->seq_t, req->uint1);
733 break;
734
735 case REQ_SEQ_REMOVE:
736 req->result = req->seq->remove (req->seq, req->txn, req->uint1);
711 break; 737 break;
712 738
713 default: 739 default:
714 req->result = ENOSYS; 740 req->result = ENOSYS;
715 break; 741 break;
… …
808 834
809#define SvPTR(var, arg, type, class, nullok) \ 835#define SvPTR(var, arg, type, class, nullok) \
810 if (!SvOK (arg)) \ 836 if (!SvOK (arg)) \
811 { \ 837 { \
812 if (!nullok) \ 838 if (!nullok) \
813 Perl_croak (# var " must be a " # class " object, not undef"); \ 839 croak (# var " must be a " # class " object, not undef"); \
814 \ 840 \
815 (var) = 0; \ 841 (var) = 0; \
816 } \ 842 } \
817 else if (sv_derived_from ((arg), # class)) \ 843 else if (sv_derived_from ((arg), # class)) \
818 { \ 844 { \
819 IV tmp = SvIV ((SV*) SvRV (arg)); \ 845 IV tmp = SvIV ((SV*) SvRV (arg)); \
820 (var) = INT2PTR (type, tmp); \ 846 (var) = INT2PTR (type, tmp); \
821 if (!var) \ 847 if (!var) \
822 Perl_croak (# var " is not a valid " # class " object anymore"); \ 848 croak (# var " is not a valid " # class " object anymore"); \
823 } \ 849 } \
824 else \ 850 else \
825 Perl_croak (# var " is not of type " # class); \ 851 croak (# var " is not of type " # class); \
826 \ 852 \
827 853
828static void 854static void
829ptr_nuke (SV *sv) 855ptr_nuke (SV *sv)
830{ 856{
… …
952 const_iv (AFTER) 978 const_iv (AFTER)
953 const_iv (CURRENT) 979 const_iv (CURRENT)
954 const_iv (KEYFIRST) 980 const_iv (KEYFIRST)
955 const_iv (KEYLAST) 981 const_iv (KEYLAST)
956 const_iv (NODUPDATA) 982 const_iv (NODUPDATA)
983
984 const_iv (FORCE)
985
986 const_iv (LOCK_DEFAULT)
987 const_iv (LOCK_EXPIRE)
988 const_iv (LOCK_MAXLOCKS)
989 const_iv (LOCK_MAXWRITE)
990 const_iv (LOCK_MINLOCKS)
991 const_iv (LOCK_MINWRITE)
992 const_iv (LOCK_OLDEST)
993 const_iv (LOCK_RANDOM)
994 const_iv (LOCK_YOUNGEST)
995
996 const_iv (SEQ_DEC)
997 const_iv (SEQ_INC)
998 const_iv (SEQ_WRAP)
957 }; 999 };
958 1000
959 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1001 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
960 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 1002 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
961 1003
962 create_pipe (); 1004 create_pipe ();
963 pthread_atfork (atfork_prepare, atfork_parent, atfork_child); 1005 ATFORK (atfork_prepare, atfork_parent, atfork_child);
964} 1006}
965 1007
966void 1008void
967max_poll_reqs (int nreqs) 1009max_poll_reqs (int nreqs)
968 PROTOTYPE: $ 1010 PROTOTYPE: $
… …
1100 PROTOTYPE: & 1142 PROTOTYPE: &
1101 CODE: 1143 CODE:
1102 SvREFCNT_dec (prepare_cb); 1144 SvREFCNT_dec (prepare_cb);
1103 prepare_cb = newSVsv (cb); 1145 prepare_cb = newSVsv (cb);
1104 1146
1147
1105DB_ENV * 1148DB_ENV *
1106db_env_create (U32 env_flags = 0) 1149db_env_create (U32 env_flags = 0)
1107 CODE: 1150 CODE:
1108{ 1151{
1109 errno = db_env_create (&RETVAL, env_flags); 1152 errno = db_env_create (&RETVAL, env_flags);
… …
1115 1158
1116void 1159void
1117db_env_open (DB_ENV *env, octetstring db_home, U32 open_flags, int mode, SV *callback = &PL_sv_undef) 1160db_env_open (DB_ENV *env, octetstring db_home, U32 open_flags, int mode, SV *callback = &PL_sv_undef)
1118 CODE: 1161 CODE:
1119{ 1162{
1163 env->set_thread_count (env, get_nthreads ());
1164
1120 dREQ (REQ_ENV_OPEN); 1165 dREQ (REQ_ENV_OPEN);
1121 req->env = env; 1166 req->env = env;
1122 req->uint1 = open_flags | DB_THREAD; 1167 req->uint1 = open_flags | DB_THREAD;
1123 req->int1 = mode; 1168 req->int1 = mode;
1124 req->buf1 = strdup_ornull (db_home); 1169 req->buf1 = strdup_ornull (db_home);
… …
1133 req->env = env; 1178 req->env = env;
1134 req->uint1 = flags; 1179 req->uint1 = flags;
1135 REQ_SEND; 1180 REQ_SEND;
1136 ptr_nuke (ST (0)); 1181 ptr_nuke (ST (0));
1137} 1182}
1183
1184void
1185db_env_txn_checkpoint (DB_ENV *env, U32 kbyte = 0, U32 min = 0, U32 flags = 0, SV *callback = &PL_sv_undef)
1186 CODE:
1187{
1188 dREQ (REQ_ENV_TXN_CHECKPOINT);
1189 req->env = env;
1190 req->uint1 = kbyte;
1191 req->int1 = min;
1192 req->uint2 = flags;
1193 REQ_SEND;
1194}
1195
1196void
1197db_env_lock_detect (DB_ENV *env, U32 flags = 0, U32 atype = DB_LOCK_DEFAULT, SV *dummy = 0, SV *callback = &PL_sv_undef)
1198 CODE:
1199{
1200 dREQ (REQ_ENV_LOCK_DETECT);
1201 req->env = env;
1202 req->uint1 = flags;
1203 req->uint2 = atype;
1204 REQ_SEND;
1205}
1206
1207void
1208db_env_memp_sync (DB_ENV *env, SV *dummy = 0, SV *callback = &PL_sv_undef)
1209 CODE:
1210{
1211 dREQ (REQ_ENV_MEMP_SYNC);
1212 req->env = env;
1213 REQ_SEND;
1214}
1215
1216void
1217db_env_memp_trickle (DB_ENV *env, int percent, SV *dummy = 0, SV *callback = &PL_sv_undef)
1218 CODE:
1219{
1220 dREQ (REQ_ENV_MEMP_TRICKLE);
1221 req->env = env;
1222 req->int1 = percent;
1223 REQ_SEND;
1224}
1225
1138 1226
1139DB * 1227DB *
1140db_create (DB_ENV *env = 0, U32 flags = 0) 1228db_create (DB_ENV *env = 0, U32 flags = 0)
1141 CODE: 1229 CODE:
1142{ 1230{
… …
1199 req->uint1 = flags; 1287 req->uint1 = flags;
1200 REQ_SEND; 1288 REQ_SEND;
1201} 1289}
1202 1290
1203void 1291void
1292db_key_range (DB *db, DB_TXN_ornull *txn, SV *key, SV *key_range, U32 flags = 0, SV *callback = &PL_sv_undef)
1293 CODE:
1294{
1295 dREQ (REQ_DB_KEY_RANGE);
1296 req->db = db;
1297 req->txn = txn;
1298 sv_to_dbt (&req->dbt1, key);
1299 req->uint1 = flags;
1300 req->sv1 = SvREFCNT_inc (key_range); SvREADONLY_on (key_range);
1301 REQ_SEND;
1302}
1303
1304void
1204db_put (DB *db, DB_TXN_ornull *txn, SV *key, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef) 1305db_put (DB *db, DB_TXN_ornull *txn, SV *key, SV *data, U32 flags = 0, SV *callback = &PL_sv_undef)
1205 CODE: 1306 CODE:
1206{ 1307{
1207 dREQ (REQ_DB_PUT); 1308 dREQ (REQ_DB_PUT);
1208 req->db = db; 1309 req->db = db;
… …
1369 req->uint1 = flags; 1470 req->uint1 = flags;
1370 REQ_SEND; 1471 REQ_SEND;
1371} 1472}
1372 1473
1373 1474
1475void
1476db_sequence_open (DB_SEQUENCE *seq, DB_TXN_ornull *txnid, SV *key, U32 flags = 0, SV *callback = &PL_sv_undef)
1477 CODE:
1478{
1479 dREQ (REQ_SEQ_OPEN);
1480 req->seq = seq;
1481 req->txn = txnid;
1482 req->uint1 = flags | DB_THREAD;
1483 sv_to_dbt (&req->dbt1, key);
1484 REQ_SEND;
1485}
1486
1487void
1488db_sequence_close (DB_SEQUENCE *seq, U32 flags = 0, SV *callback = &PL_sv_undef)
1489 CODE:
1490{
1491 dREQ (REQ_SEQ_CLOSE);
1492 req->seq = seq;
1493 req->uint1 = flags;
1494 REQ_SEND;
1495 ptr_nuke (ST (0));
1496}
1497
1498void
1499db_sequence_get (DB_SEQUENCE *seq, DB_TXN_ornull *txnid, int delta, SV *seq_value, U32 flags = DB_TXN_NOSYNC, SV *callback = &PL_sv_undef)
1500 CODE:
1501{
1502 dREQ (REQ_SEQ_GET);
1503 req->seq = seq;
1504 req->txn = txnid;
1505 req->int1 = delta;
1506 req->uint1 = flags;
1507 req->sv1 = SvREFCNT_inc (seq_value); SvREADONLY_on (seq_value);
1508 REQ_SEND;
1509}
1510
1511void
1512db_sequence_remove (DB_SEQUENCE *seq, DB_TXN_ornull *txnid = 0, U32 flags = 0, SV *callback = &PL_sv_undef)
1513 CODE:
1514{
1515 dREQ (REQ_SEQ_REMOVE);
1516 req->seq = seq;
1517 req->txn = txnid;
1518 req->uint1 = flags;
1519 REQ_SEND;
1520}
1521
1522
1374MODULE = BDB PACKAGE = BDB::Env 1523MODULE = BDB PACKAGE = BDB::Env
1375 1524
1376void 1525void
1377DESTROY (DB_ENV_ornull *env) 1526DESTROY (DB_ENV_ornull *env)
1378 CODE: 1527 CODE:
1379 if (env) 1528 if (env)
1380 env->close (env, 0); 1529 env->close (env, 0);
1381 1530
1531int set_data_dir (DB_ENV *env, const char *dir)
1532 CODE:
1533 RETVAL = env->set_data_dir (env, dir);
1534 OUTPUT:
1535 RETVAL
1536
1537int set_tmp_dir (DB_ENV *env, const char *dir)
1538 CODE:
1539 RETVAL = env->set_tmp_dir (env, dir);
1540 OUTPUT:
1541 RETVAL
1542
1543int set_lg_dir (DB_ENV *env, const char *dir)
1544 CODE:
1545 RETVAL = env->set_lg_dir (env, dir);
1546 OUTPUT:
1547 RETVAL
1548
1549int set_shm_key (DB_ENV *env, long shm_key)
1550 CODE:
1551 RETVAL = env->set_shm_key (env, shm_key);
1552 OUTPUT:
1553 RETVAL
1554
1382int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0) 1555int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0)
1383 CODE: 1556 CODE:
1384 RETVAL = env->set_cachesize (env, gbytes, bytes, ncache); 1557 RETVAL = env->set_cachesize (env, gbytes, bytes, ncache);
1385 OUTPUT: 1558 OUTPUT:
1386 RETVAL 1559 RETVAL
… …
1398 RETVAL 1571 RETVAL
1399 1572
1400int set_timeout (DB_ENV *env, NV timeout, U32 flags) 1573int set_timeout (DB_ENV *env, NV timeout, U32 flags)
1401 CODE: 1574 CODE:
1402 RETVAL = env->set_timeout (env, timeout * 1000000, flags); 1575 RETVAL = env->set_timeout (env, timeout * 1000000, flags);
1576 OUTPUT:
1577 RETVAL
1578
1579int set_mp_max_openfd (DB_ENV *env, int maxopenfd);
1580 CODE:
1581 RETVAL = env->set_mp_max_openfd (env, maxopenfd);
1582 OUTPUT:
1583 RETVAL
1584
1585int set_mp_max_write (DB_ENV *env, int maxwrite, int maxwrite_sleep);
1586 CODE:
1587 RETVAL = env->set_mp_max_write (env, maxwrite, maxwrite_sleep);
1588 OUTPUT:
1589 RETVAL
1590
1591int set_mp_mmapsize (DB_ENV *env, int mmapsize_mb)
1592 CODE:
1593 RETVAL = env->set_mp_mmapsize (env, ((size_t)mmapsize_mb) << 20);
1594 OUTPUT:
1595 RETVAL
1596
1597int set_lk_detect (DB_ENV *env, U32 detect = DB_LOCK_DEFAULT)
1598 CODE:
1599 RETVAL = env->set_lk_detect (env, detect);
1600 OUTPUT:
1601 RETVAL
1602
1603int set_lk_max_lockers (DB_ENV *env, U32 max)
1604 CODE:
1605 RETVAL = env->set_lk_max_lockers (env, max);
1606 OUTPUT:
1607 RETVAL
1608
1609int set_lk_max_locks (DB_ENV *env, U32 max)
1610 CODE:
1611 RETVAL = env->set_lk_max_locks (env, max);
1612 OUTPUT:
1613 RETVAL
1614
1615int set_lk_max_objects (DB_ENV *env, U32 max)
1616 CODE:
1617 RETVAL = env->set_lk_max_objects (env, max);
1618 OUTPUT:
1619 RETVAL
1620
1621int set_lg_bsize (DB_ENV *env, U32 max)
1622 CODE:
1623 RETVAL = env->set_lg_bsize (env, max);
1624 OUTPUT:
1625 RETVAL
1626
1627int set_lg_max (DB_ENV *env, U32 max)
1628 CODE:
1629 RETVAL = env->set_lg_max (env, max);
1403 OUTPUT: 1630 OUTPUT:
1404 RETVAL 1631 RETVAL
1405 1632
1406DB_TXN * 1633DB_TXN *
1407txn_begin (DB_ENV *env, DB_TXN_ornull *parent = 0, U32 flags = 0) 1634txn_begin (DB_ENV *env, DB_TXN_ornull *parent = 0, U32 flags = 0)
… …
1446 CODE: 1673 CODE:
1447 RETVAL = db->set_lorder (db, lorder); 1674 RETVAL = db->set_lorder (db, lorder);
1448 OUTPUT: 1675 OUTPUT:
1449 RETVAL 1676 RETVAL
1450 1677
1451
1452int set_bt_minkey (DB *db, U32 minkey) 1678int set_bt_minkey (DB *db, U32 minkey)
1453 CODE: 1679 CODE:
1454 RETVAL = db->set_bt_minkey (db, minkey); 1680 RETVAL = db->set_bt_minkey (db, minkey);
1455 OUTPUT: 1681 OUTPUT:
1456 RETVAL 1682 RETVAL
… …
1504 if (errno) 1730 if (errno)
1505 croak ("DB->cursor: %s", db_strerror (errno)); 1731 croak ("DB->cursor: %s", db_strerror (errno));
1506 OUTPUT: 1732 OUTPUT:
1507 RETVAL 1733 RETVAL
1508 1734
1735DB_SEQUENCE *
1736sequence (DB *db, U32 flags = 0)
1737 CODE:
1738{
1739 errno = db_sequence_create (&RETVAL, db, flags);
1740 if (errno)
1741 croak ("db_sequence_create: %s", db_strerror (errno));
1742}
1743 OUTPUT:
1744 RETVAL
1745
1509 1746
1510MODULE = BDB PACKAGE = BDB::Txn 1747MODULE = BDB PACKAGE = BDB::Txn
1511 1748
1512void 1749void
1513DESTROY (DB_TXN_ornull *txn) 1750DESTROY (DB_TXN_ornull *txn)
… …
1528DESTROY (DBC_ornull *dbc) 1765DESTROY (DBC_ornull *dbc)
1529 CODE: 1766 CODE:
1530 if (dbc) 1767 if (dbc)
1531 dbc->c_close (dbc); 1768 dbc->c_close (dbc);
1532 1769
1770MODULE = BDB PACKAGE = BDB::Sequence
1771
1772void
1773DESTROY (DB_SEQUENCE_ornull *seq)
1774 CODE:
1775 if (seq)
1776 seq->close (seq, 0);
1777
1778int initial_value (DB_SEQUENCE *seq, db_seq_t value)
1779 CODE:
1780 RETVAL = seq->initial_value (seq, value);
1781 OUTPUT:
1782 RETVAL
1783
1784int set_cachesize (DB_SEQUENCE *seq, U32 size)
1785 CODE:
1786 RETVAL = seq->set_cachesize (seq, size);
1787 OUTPUT:
1788 RETVAL
1789
1790int set_flags (DB_SEQUENCE *seq, U32 flags)
1791 CODE:
1792 RETVAL = seq->set_flags (seq, flags);
1793 OUTPUT:
1794 RETVAL
1795
1796int set_range (DB_SEQUENCE *seq, db_seq_t min, db_seq_t max)
1797 CODE:
1798 RETVAL = seq->set_range (seq, min, max);
1799 OUTPUT:
1800 RETVAL
1801

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines