[ViewVC] Diff of: cvs/BDB/BDB.xs

Comparing BDB/BDB.xs (file contents):
Revision 1.1 by root, Mon Feb 5 18:40:55 2007 UTC vs.
Revision 1.10 by root, Mon Mar 5 19:47:01 2007 UTC

…		…
18		18
19	#include <stddef.h>	19	#include <stddef.h>
20	#include <stdlib.h>	20	#include <stdlib.h>
21	#include <errno.h>	21	#include <errno.h>
22	#include <sys/time.h>	22	#include <sys/time.h>
23	#include <sys/select.h>
24	#include <sys/types.h>	23	#include <sys/types.h>
25	#include <sys/stat.h>
26	#include <limits.h>	24	#include <limits.h>
27	#include <unistd.h>	25	#include <unistd.h>
28	#include <fcntl.h>	26	#include <fcntl.h>
29	#include <signal.h>	27
30	#include <sched.h>	28	#include <db.h>
		29
		30	#if DB_VERSION_MAJOR < 4 \|\| (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR < 5)
		31	# error you need Berkeley DB 4.5 or newer installed
		32	#endif
31		33
32	/* number of seconds after which idle threads exit */	34	/* number of seconds after which idle threads exit */
33	#define IDLE_TIMEOUT 10	35	#define IDLE_TIMEOUT 10
34		36
35	/* wether word reads are potentially non-atomic.	37	/* wether word reads are potentially non-atomic.
…		…
42	# else	44	# else
43	# define WORDACCESS_UNSAFE 1	45	# define WORDACCESS_UNSAFE 1
44	# endif	46	# endif
45	#endif	47	#endif
46		48
		49	typedef DB_ENV DB_ENV_ornull;
		50	typedef DB_TXN DB_TXN_ornull;
		51	typedef DBC DBC_ornull;
		52	typedef DB DB_ornull;
		53	typedef DB_SEQUENCE DB_SEQUENCE_ornull;
		54
47	typedef SV SV8; /* byte-sv, used for argument-checking */	55	typedef SV SV8; /* byte-sv, used for argument-checking */
		56	typedef char *octetstring;
48		57
		58	static SV *prepare_cb;
		59
		60	static inline char *
		61	strdup_ornull (const char *s)
		62	{
		63	return s ? strdup (s) : 0;
		64	}
		65
		66	static inline void
		67	sv_to_dbt (DBT dbt, SV sv)
		68	{
		69	STRLEN len;
		70	char *data = SvPVbyte (sv, len);
		71
		72	dbt->data = malloc (len);
		73	memcpy (dbt->data, data, len);
		74	dbt->size = len;
		75	dbt->flags = DB_DBT_REALLOC;
		76	}
		77
		78	static inline void
		79	dbt_to_sv (SV sv, DBT dbt)
		80	{
		81	if (sv)
		82	{
		83	SvREADONLY_off (sv);
		84	sv_setpvn_mg (sv, dbt->data, dbt->size);
		85	SvREFCNT_dec (sv);
		86	}
		87
		88	free (dbt->data);
		89	}
		90
49	enum {	91	enum {
50	REQ_QUIT,	92	REQ_QUIT,
		93	REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT,
		94	REQ_ENV_MEMP_SYNC, REQ_ENV_MEMP_TRICKLE,
		95	REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC,
		96	REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET, REQ_DB_DEL, REQ_DB_KEY_RANGE,
		97	REQ_TXN_COMMIT, REQ_TXN_ABORT,
		98	REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL,
		99	REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE,
51	};	100	};
52		101
53	#define AIO_CB \
54	struct aio_cb *volatile next; \
55	SV *callback; \
56	int type, pri
57
58	typedef struct aio_cb	102	typedef struct aio_cb
59	{	103	{
60	AIO_CB;	104	struct aio_cb *volatile next;
		105	SV *callback;
		106	int type, pri, result;
		107
		108	DB_ENV *env;
		109	DB *db;
		110	DB_TXN *txn;
		111	DBC *dbc;
		112
		113	UV uv1;
		114	int int1, int2;
		115	U32 uint1, uint2;
		116	char buf1, buf2;
		117	SV sv1, sv2, *sv3;
		118
		119	DBT dbt1, dbt2, dbt3;
		120	DB_KEY_RANGE key_range;
		121	DB_SEQUENCE *seq;
		122	db_seq_t seq_t;
61	} aio_cb;	123	} aio_cb;
62		124
63	typedef aio_cb *aio_req;	125	typedef aio_cb *aio_req;
64		126
65	enum {	127	enum {
…		…
230		292
231	abort ();	293	abort ();
232	}	294	}
233		295
234	static int poll_cb ();	296	static int poll_cb ();
235	static int req_invoke (aio_req req);
236	static void req_free (aio_req req);	297	static void req_free (aio_req req);
237	static void req_cancel (aio_req req);	298	static void req_cancel (aio_req req);
238		299
239	static int req_invoke (aio_req req)	300	static int req_invoke (aio_req req)
240	{	301	{
…		…
243	if (SvOK (req->callback))	304	if (SvOK (req->callback))
244	{	305	{
245	ENTER;	306	ENTER;
246	SAVETMPS;	307	SAVETMPS;
247	PUSHMARK (SP);	308	PUSHMARK (SP);
248	EXTEND (SP, 1);
249		309
250	switch (req->type)	310	switch (req->type)
251	{	311	{
		312	case REQ_DB_CLOSE:
		313	SvREFCNT_dec (req->sv1);
		314	break;
		315
		316	case REQ_DB_GET:
		317	case REQ_DB_PGET:
		318	dbt_to_sv (req->sv3, &req->dbt3);
		319	break;
		320
		321	case REQ_C_GET:
		322	case REQ_C_PGET:
		323	dbt_to_sv (req->sv1, &req->dbt1);
		324	dbt_to_sv (req->sv2, &req->dbt2);
		325	dbt_to_sv (req->sv3, &req->dbt3);
		326	break;
		327
		328	case REQ_DB_KEY_RANGE:
		329	{
		330	AV *av = newAV ();
		331
		332	av_push (av, newSVnv (req->key_range.less));
		333	av_push (av, newSVnv (req->key_range.equal));
		334	av_push (av, newSVnv (req->key_range.greater));
		335
		336	SvREADONLY_off (req->sv1);
		337	sv_setsv_mg (req->sv1, newRV_noinc ((SV *)av));
		338	SvREFCNT_dec (req->sv1);
		339	}
		340	break;
		341
		342	case REQ_SEQ_GET:
		343	SvREADONLY_off (req->sv1);
		344
		345	if (sizeof (IV) > 4)
		346	sv_setiv_mg (req->sv1, req->seq_t);
		347	else
		348	sv_setnv_mg (req->sv1, req->seq_t);
		349
		350	SvREFCNT_dec (req->sv1);
		351	break;
252	}	352	}
		353
		354	errno = req->result;
253		355
254	PUTBACK;	356	PUTBACK;
255	call_sv (req->callback, G_VOID \| G_EVAL);	357	call_sv (req->callback, G_VOID \| G_EVAL);
256	SPAGAIN;	358	SPAGAIN;
257		359
…		…
262	return !SvTRUE (ERRSV);	364	return !SvTRUE (ERRSV);
263	}	365	}
264		366
265	static void req_free (aio_req req)	367	static void req_free (aio_req req)
266	{	368	{
		369	free (req->buf1);
		370	free (req->buf2);
267	Safefree (req);	371	Safefree (req);
268	}	372	}
269		373
270	static void aio_proc(void arg);	374	static void aio_proc (void arg);
271		375
272	static void start_thread (void)	376	static void start_thread (void)
273	{	377	{
274	sigset_t fullsigset, oldsigset;	378	sigset_t fullsigset, oldsigset;
275	pthread_attr_t attr;	379	pthread_attr_t attr;
…		…
317	start_thread ();	421	start_thread ();
318	}	422	}
319		423
320	static void req_send (aio_req req)	424	static void req_send (aio_req req)
321	{	425	{
		426	SV *wait_callback = 0;
		427
		428	// synthesize callback if none given
		429	if (!SvOK (req->callback))
		430	{
		431	dSP;
		432	PUSHMARK (SP);
		433	PUTBACK;
		434	int count = call_sv (prepare_cb, G_ARRAY);
		435	SPAGAIN;
		436
		437	if (count != 2)
		438	croak ("prepare callback must return exactly two values\n");
		439
		440	wait_callback = SvREFCNT_inc (POPs);
		441	SvREFCNT_dec (req->callback);
		442	req->callback = SvREFCNT_inc (POPs);
		443	}
		444
322	++nreqs;	445	++nreqs;
323		446
324	LOCK (reqlock);	447	LOCK (reqlock);
325	++nready;	448	++nready;
326	reqq_push (&req_queue, req);	449	reqq_push (&req_queue, req);
327	pthread_cond_signal (&reqwait);	450	pthread_cond_signal (&reqwait);
328	UNLOCK (reqlock);	451	UNLOCK (reqlock);
329		452
330	maybe_start_thread ();	453	maybe_start_thread ();
		454
		455	if (wait_callback)
		456	{
		457	dSP;
		458	PUSHMARK (SP);
		459	PUTBACK;
		460	call_sv (wait_callback, G_DISCARD);
		461	SvREFCNT_dec (wait_callback);
		462	}
331	}	463	}
332		464
333	static void end_thread (void)	465	static void end_thread (void)
334	{	466	{
335	aio_req req;	467	aio_req req;
…		…
530		662
531	--nready;	663	--nready;
532		664
533	UNLOCK (reqlock);	665	UNLOCK (reqlock);
534		666
535	errno = 0; /* strictly unnecessary */
536
537	switch (req->type)	667	switch (req->type)
538	{	668	{
539	case REQ_QUIT:	669	case REQ_QUIT:
540	goto quit;	670	goto quit;
541		671
		672	case REQ_ENV_OPEN:
		673	req->result = req->env->open (req->env, req->buf1, req->uint1, req->int1);
		674	break;
		675
		676	case REQ_ENV_CLOSE:
		677	req->result = req->env->close (req->env, req->uint1);
		678	break;
		679
		680	case REQ_ENV_TXN_CHECKPOINT:
		681	req->result = req->env->txn_checkpoint (req->env, req->uint1, req->int1, req->uint2);
		682	break;
		683
		684	case REQ_ENV_LOCK_DETECT:
		685	req->result = req->env->lock_detect (req->env, req->uint1, req->uint2, &req->int1);
		686	break;
		687
		688	case REQ_ENV_MEMP_SYNC:
		689	req->result = req->env->memp_sync (req->env, 0);
		690	break;
		691
		692	case REQ_ENV_MEMP_TRICKLE:
		693	req->result = req->env->memp_trickle (req->env, req->int1, &req->int2);
		694	break;
		695
		696	case REQ_DB_OPEN:
		697	req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
		698	break;
		699
		700	case REQ_DB_CLOSE:
		701	req->result = req->db->close (req->db, req->uint1);
		702	break;
		703
		704	case REQ_DB_COMPACT:
		705	req->result = req->db->compact (req->db, req->txn, &req->dbt1, &req->dbt2, 0, req->uint1, 0);
		706	break;
		707
		708	case REQ_DB_SYNC:
		709	req->result = req->db->sync (req->db, req->uint1);
		710	break;
		711
		712	case REQ_DB_PUT:
		713	req->result = req->db->put (req->db, req->txn, &req->dbt1, &req->dbt2, req->uint1);
		714	break;
		715
		716	case REQ_DB_GET:
		717	req->result = req->db->get (req->db, req->txn, &req->dbt1, &req->dbt3, req->uint1);
		718	break;
		719
		720	case REQ_DB_PGET:
		721	req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
		722	break;
		723
		724	case REQ_DB_DEL:
		725	req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);
		726	break;
		727
		728	case REQ_DB_KEY_RANGE:
		729	req->result = req->db->key_range (req->db, req->txn, &req->dbt1, &req->key_range, req->uint1);
		730	break;
		731
		732	case REQ_TXN_COMMIT:
		733	req->result = req->txn->commit (req->txn, req->uint1);
		734	break;
		735
		736	case REQ_TXN_ABORT:
		737	req->result = req->txn->abort (req->txn);
		738	break;
		739
		740	case REQ_C_CLOSE:
		741	req->result = req->dbc->c_close (req->dbc);
		742	break;
		743
		744	case REQ_C_COUNT:
		745	{
		746	db_recno_t recno;
		747	req->result = req->dbc->c_count (req->dbc, &recno, req->uint1);
		748	req->uv1 = recno;
		749	}
		750	break;
		751
		752	case REQ_C_PUT:
		753	req->result = req->dbc->c_put (req->dbc, &req->dbt1, &req->dbt2, req->uint1);
		754	break;
		755
		756	case REQ_C_GET:
		757	req->result = req->dbc->c_get (req->dbc, &req->dbt1, &req->dbt3, req->uint1);
		758	break;
		759
		760	case REQ_C_PGET:
		761	req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
		762	break;
		763
		764	case REQ_C_DEL:
		765	req->result = req->dbc->c_del (req->dbc, req->uint1);
		766	break;
		767
		768	case REQ_SEQ_OPEN:
		769	req->result = req->seq->open (req->seq, req->txn, &req->dbt1, req->uint1);
		770	break;
		771
		772	case REQ_SEQ_CLOSE:
		773	req->result = req->seq->close (req->seq, req->uint1);
		774	break;
		775
		776	case REQ_SEQ_GET:
		777	req->result = req->seq->get (req->seq, req->txn, req->int1, &req->seq_t, req->uint1);
		778	break;
		779
		780	case REQ_SEQ_REMOVE:
		781	req->result = req->seq->remove (req->seq, req->txn, req->uint1);
		782	break;
		783
542	default:	784	default:
543	//req->result = ENOSYS;	785	req->result = ENOSYS;
544	break;	786	break;
545	}	787	}
546
547	//req->errorno = errno;
548		788
549	LOCK (reslock);	789	LOCK (reslock);
550		790
551	++npending;	791	++npending;
552		792
…		…
616	create_pipe ();	856	create_pipe ();
617		857
618	atfork_parent ();	858	atfork_parent ();
619	}	859	}
620		860
621	#define dREQ \	861	#define dREQ(reqtype) \
622	aio_req req; \	862	aio_req req; \
623	int req_pri = next_pri; \	863	int req_pri = next_pri; \
624	next_pri = DEFAULT_PRI + PRI_BIAS; \	864	next_pri = DEFAULT_PRI + PRI_BIAS; \
625	\	865	\
626	if (SvOK (callback) && !SvROK (callback)) \	866	if (SvOK (callback) && !SvROK (callback)) \
627	croak ("callback must be undef or of reference type"); \	867	croak ("callback must be undef or of reference type"); \
628	\	868	\
629	Newz (0, req, 1, aio_cb); \	869	Newz (0, req, 1, aio_cb); \
630	if (!req) \	870	if (!req) \
631	croak ("out of memory during aio_req allocation"); \	871	croak ("out of memory during aio_req allocation"); \
632	\	872	\
633	req->callback = newSVsv (callback); \	873	req->callback = newSVsv (callback); \
		874	req->type = (reqtype); \
634	req->pri = req_pri	875	req->pri = req_pri
635		876
636	#define REQ_SEND \	877	#define REQ_SEND \
637	req_send (req); \	878	req_send (req)
		879
		880	#define SvPTR(var, arg, type, class, nullok) \
		881	if (!SvOK (arg)) \
		882	{ \
		883	if (!nullok) \
		884	croak (# var " must be a " # class " object, not undef"); \
638	\	885	\
639	if (GIMME_V != G_VOID) \	886	(var) = 0; \
640	XPUSHs (req_sv (req, AIO_REQ_KLASS));	887	} \
641		888	else if (sv_derived_from ((arg), # class)) \
		889	{ \
		890	IV tmp = SvIV ((SV*) SvRV (arg)); \
		891	(var) = INT2PTR (type, tmp); \
		892	if (!var) \
		893	croak (# var " is not a valid " # class " object anymore"); \
		894	} \
		895	else \
		896	croak (# var " is not of type " # class); \
		897	\
		898
		899	static void
		900	ptr_nuke (SV *sv)
		901	{
		902	assert (SvROK (sv));
		903	sv_setiv (SvRV (sv), 0);
		904	}
		905
642	MODULE = BDB::AIO PACKAGE = BDB::AIO	906	MODULE = BDB PACKAGE = BDB
643		907
644	PROTOTYPES: ENABLE	908	PROTOTYPES: ENABLE
645		909
646	BOOT:	910	BOOT:
647	{	911	{
648	HV *stash = gv_stashpv ("BDB::AIO", 1);	912	HV *stash = gv_stashpv ("BDB", 1);
		913
		914	static const struct {
		915	const char *name;
		916	IV iv;
		917	} *civ, const_iv[] = {
		918	#define const_iv(name) { # name, (IV)DB_ ## name },
		919	const_iv (RPCCLIENT)
		920	const_iv (INIT_CDB)
		921	const_iv (INIT_LOCK)
		922	const_iv (INIT_LOG)
		923	const_iv (INIT_MPOOL)
		924	const_iv (INIT_REP)
		925	const_iv (INIT_TXN)
		926	const_iv (RECOVER)
		927	const_iv (INIT_TXN)
		928	const_iv (RECOVER_FATAL)
		929	const_iv (CREATE)
		930	const_iv (USE_ENVIRON)
		931	const_iv (USE_ENVIRON_ROOT)
		932	const_iv (LOCKDOWN)
		933	const_iv (PRIVATE)
		934	const_iv (REGISTER)
		935	const_iv (SYSTEM_MEM)
		936	const_iv (AUTO_COMMIT)
		937	const_iv (CDB_ALLDB)
		938	const_iv (DIRECT_DB)
		939	const_iv (DIRECT_LOG)
		940	const_iv (DSYNC_DB)
		941	const_iv (DSYNC_LOG)
		942	const_iv (LOG_AUTOREMOVE)
		943	const_iv (LOG_INMEMORY)
		944	const_iv (NOLOCKING)
		945	const_iv (MULTIVERSION)
		946	const_iv (NOMMAP)
		947	const_iv (NOPANIC)
		948	const_iv (OVERWRITE)
		949	const_iv (PANIC_ENVIRONMENT)
		950	const_iv (REGION_INIT)
		951	const_iv (TIME_NOTGRANTED)
		952	const_iv (TXN_NOSYNC)
		953	const_iv (TXN_SNAPSHOT)
		954	const_iv (TXN_WRITE_NOSYNC)
		955	const_iv (WRITECURSOR)
		956	const_iv (YIELDCPU)
		957	const_iv (ENCRYPT_AES)
		958	const_iv (XA_CREATE)
		959	const_iv (BTREE)
		960	const_iv (HASH)
		961	const_iv (QUEUE)
		962	const_iv (RECNO)
		963	const_iv (UNKNOWN)
		964	const_iv (EXCL)
		965	const_iv (READ_COMMITTED)
		966	const_iv (READ_UNCOMMITTED)
		967	const_iv (TRUNCATE)
		968	const_iv (NOSYNC)
		969	const_iv (CHKSUM)
		970	const_iv (ENCRYPT)
		971	const_iv (TXN_NOT_DURABLE)
		972	const_iv (DUP)
		973	const_iv (DUPSORT)
		974	const_iv (RECNUM)
		975	const_iv (RENUMBER)
		976	const_iv (REVSPLITOFF)
		977	const_iv (INORDER)
		978	const_iv (CONSUME)
		979	const_iv (CONSUME_WAIT)
		980	const_iv (GET_BOTH)
		981	const_iv (GET_BOTH_RANGE)
		982	//const_iv (SET_RECNO)
		983	//const_iv (MULTIPLE)
		984	const_iv (SNAPSHOT)
		985	const_iv (JOIN_ITEM)
		986	const_iv (RMW)
		987
		988	const_iv (NOTFOUND)
		989	const_iv (KEYEMPTY)
		990	const_iv (LOCK_DEADLOCK)
		991	const_iv (LOCK_NOTGRANTED)
		992	const_iv (RUNRECOVERY)
		993	const_iv (OLD_VERSION)
		994	const_iv (REP_HANDLE_DEAD)
		995	const_iv (REP_LOCKOUT)
		996	const_iv (SECONDARY_BAD)
		997
		998	const_iv (FREE_SPACE)
		999	const_iv (FREELIST_ONLY)
		1000
		1001	const_iv (APPEND)
		1002	const_iv (NODUPDATA)
		1003	const_iv (NOOVERWRITE)
		1004
		1005	const_iv (TXN_NOWAIT)
		1006	const_iv (TXN_SNAPSHOT)
		1007	const_iv (TXN_SYNC)
		1008
		1009	const_iv (SET_LOCK_TIMEOUT)
		1010	const_iv (SET_TXN_TIMEOUT)
		1011
		1012	const_iv (JOIN_ITEM)
		1013	const_iv (FIRST)
		1014	const_iv (NEXT)
		1015	const_iv (NEXT_DUP)
		1016	const_iv (NEXT_NODUP)
		1017	const_iv (PREV)
		1018	const_iv (PREV_NODUP)
		1019	const_iv (SET)
		1020	const_iv (SET_RANGE)
		1021	const_iv (LAST)
		1022	const_iv (BEFORE)
		1023	const_iv (AFTER)
		1024	const_iv (CURRENT)
		1025	const_iv (KEYFIRST)
		1026	const_iv (KEYLAST)
		1027	const_iv (NODUPDATA)
		1028
		1029	const_iv (FORCE)
		1030
		1031	const_iv (LOCK_DEFAULT)
		1032	const_iv (LOCK_EXPIRE)
		1033	const_iv (LOCK_MAXLOCKS)
		1034	const_iv (LOCK_MAXWRITE)
		1035	const_iv (LOCK_MINLOCKS)
		1036	const_iv (LOCK_MINWRITE)
		1037	const_iv (LOCK_OLDEST)
		1038	const_iv (LOCK_RANDOM)
		1039	const_iv (LOCK_YOUNGEST)
		1040
		1041	const_iv (SEQ_DEC)
		1042	const_iv (SEQ_INC)
		1043	const_iv (SEQ_WRAP)
		1044	};
		1045
		1046	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
		1047	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
649		1048
650	create_pipe ();	1049	create_pipe ();
651	pthread_atfork (atfork_prepare, atfork_parent, atfork_child);	1050	pthread_atfork (atfork_prepare, atfork_parent, atfork_child);
652	}	1051	}
653		1052
…		…
685	max_outstanding = maxreqs;	1084	max_outstanding = maxreqs;
686	OUTPUT:	1085	OUTPUT:
687	RETVAL	1086	RETVAL
688		1087
689	int	1088	int
690	bdbreq_pri (int pri = 0)	1089	dbreq_pri (int pri = 0)
691	PROTOTYPE: ;$	1090	PROTOTYPE: ;$
692	CODE:	1091	CODE:
693	RETVAL = next_pri - PRI_BIAS;	1092	RETVAL = next_pri - PRI_BIAS;
694	if (items > 0)	1093	if (items > 0)
695	{	1094	{
…		…
699	}	1098	}
700	OUTPUT:	1099	OUTPUT:
701	RETVAL	1100	RETVAL
702		1101
703	void	1102	void
704	bdbreq_nice (int nice = 0)	1103	dbreq_nice (int nice = 0)
705	CODE:	1104	CODE:
706	nice = next_pri - nice;	1105	nice = next_pri - nice;
707	if (nice < PRI_MIN) nice = PRI_MIN;	1106	if (nice < PRI_MIN) nice = PRI_MIN;
708	if (nice > PRI_MAX) nice = PRI_MAX;	1107	if (nice > PRI_MAX) nice = PRI_MAX;
709	next_pri = nice + PRI_BIAS;	1108	next_pri = nice + PRI_BIAS;
…		…
717	poll_wait ();	1116	poll_wait ();
718	poll_cb ();	1117	poll_cb ();
719	}	1118	}
720		1119
721	int	1120	int
722	poll()	1121	poll ()
723	PROTOTYPE:	1122	PROTOTYPE:
724	CODE:	1123	CODE:
725	poll_wait ();	1124	poll_wait ();
726	RETVAL = poll_cb ();	1125	RETVAL = poll_cb ();
727	OUTPUT:	1126	OUTPUT:
728	RETVAL	1127	RETVAL
729		1128
730	int	1129	int
731	poll_fileno()	1130	poll_fileno ()
732	PROTOTYPE:	1131	PROTOTYPE:
733	CODE:	1132	CODE:
734	RETVAL = respipe [0];	1133	RETVAL = respipe [0];
735	OUTPUT:	1134	OUTPUT:
736	RETVAL	1135	RETVAL
737		1136
738	int	1137	int
739	poll_cb(...)	1138	poll_cb (...)
740	PROTOTYPE:	1139	PROTOTYPE:
741	CODE:	1140	CODE:
742	RETVAL = poll_cb ();	1141	RETVAL = poll_cb ();
743	OUTPUT:	1142	OUTPUT:
744	RETVAL	1143	RETVAL
745		1144
746	void	1145	void
747	poll_wait()	1146	poll_wait ()
748	PROTOTYPE:	1147	PROTOTYPE:
749	CODE:	1148	CODE:
750	poll_wait ();	1149	poll_wait ();
751		1150
752	int	1151	int
753	nreqs()	1152	nreqs ()
754	PROTOTYPE:	1153	PROTOTYPE:
755	CODE:	1154	CODE:
756	RETVAL = nreqs;	1155	RETVAL = nreqs;
757	OUTPUT:	1156	OUTPUT:
758	RETVAL	1157	RETVAL
759		1158
760	int	1159	int
761	nready()	1160	nready ()
762	PROTOTYPE:	1161	PROTOTYPE:
763	CODE:	1162	CODE:
764	RETVAL = get_nready ();	1163	RETVAL = get_nready ();
765	OUTPUT:	1164	OUTPUT:
766	RETVAL	1165	RETVAL
767		1166
768	int	1167	int
769	npending()	1168	npending ()
770	PROTOTYPE:	1169	PROTOTYPE:
771	CODE:	1170	CODE:
772	RETVAL = get_npending ();	1171	RETVAL = get_npending ();
773	OUTPUT:	1172	OUTPUT:
774	RETVAL	1173	RETVAL
775		1174
776	int	1175	int
777	nthreads()	1176	nthreads ()
778	PROTOTYPE:	1177	PROTOTYPE:
779	CODE:	1178	CODE:
780	if (WORDACCESS_UNSAFE) LOCK (wrklock);	1179	if (WORDACCESS_UNSAFE) LOCK (wrklock);
781	RETVAL = started;	1180	RETVAL = started;
782	if (WORDACCESS_UNSAFE) UNLOCK (wrklock);	1181	if (WORDACCESS_UNSAFE) UNLOCK (wrklock);
783	OUTPUT:	1182	OUTPUT:
784	RETVAL	1183	RETVAL
785		1184
		1185	void
		1186	set_sync_prepare (SV *cb)
		1187	PROTOTYPE: &
		1188	CODE:
		1189	SvREFCNT_dec (prepare_cb);
		1190	prepare_cb = newSVsv (cb);
786		1191
		1192
		1193	DB_ENV *
		1194	db_env_create (U32 env_flags = 0)
		1195	CODE:
		1196	{
		1197	errno = db_env_create (&RETVAL, env_flags);
		1198	if (errno)
		1199	croak ("db_env_create: %s", db_strerror (errno));
		1200	}
		1201	OUTPUT:
		1202	RETVAL
		1203
		1204	void
		1205	db_env_open (DB_ENV env, octetstring db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)
		1206	CODE:
		1207	{
		1208	env->set_thread_count (env, get_nthreads ());
		1209
		1210	dREQ (REQ_ENV_OPEN);
		1211	req->env = env;
		1212	req->uint1 = open_flags \| DB_THREAD;
		1213	req->int1 = mode;
		1214	req->buf1 = strdup_ornull (db_home);
		1215	REQ_SEND;
		1216	}
		1217
		1218	void
		1219	db_env_close (DB_ENV env, U32 flags = 0, SV callback = &PL_sv_undef)
		1220	CODE:
		1221	{
		1222	dREQ (REQ_ENV_CLOSE);
		1223	req->env = env;
		1224	req->uint1 = flags;
		1225	REQ_SEND;
		1226	ptr_nuke (ST (0));
		1227	}
		1228
		1229	void
		1230	db_env_txn_checkpoint (DB_ENV env, U32 kbyte = 0, U32 min = 0, U32 flags = 0, SV callback = &PL_sv_undef)
		1231	CODE:
		1232	{
		1233	dREQ (REQ_ENV_TXN_CHECKPOINT);
		1234	req->env = env;
		1235	req->uint1 = kbyte;
		1236	req->int1 = min;
		1237	req->uint2 = flags;
		1238	REQ_SEND;
		1239	}
		1240
		1241	void
		1242	db_env_lock_detect (DB_ENV env, U32 flags = 0, U32 atype = DB_LOCK_DEFAULT, SV dummy = 0, SV *callback = &PL_sv_undef)
		1243	CODE:
		1244	{
		1245	dREQ (REQ_ENV_LOCK_DETECT);
		1246	req->env = env;
		1247	req->uint1 = flags;
		1248	req->uint2 = atype;
		1249	REQ_SEND;
		1250	}
		1251
		1252	void
		1253	db_env_memp_sync (DB_ENV env, SV dummy = 0, SV *callback = &PL_sv_undef)
		1254	CODE:
		1255	{
		1256	dREQ (REQ_ENV_MEMP_SYNC);
		1257	req->env = env;
		1258	REQ_SEND;
		1259	}
		1260
		1261	void
		1262	db_env_memp_trickle (DB_ENV env, int percent, SV dummy = 0, SV *callback = &PL_sv_undef)
		1263	CODE:
		1264	{
		1265	dREQ (REQ_ENV_MEMP_TRICKLE);
		1266	req->env = env;
		1267	req->int1 = percent;
		1268	REQ_SEND;
		1269	}
		1270
		1271
		1272	DB *
		1273	db_create (DB_ENV *env = 0, U32 flags = 0)
		1274	CODE:
		1275	{
		1276	errno = db_create (&RETVAL, env, flags);
		1277	if (errno)
		1278	croak ("db_create: %s", db_strerror (errno));
		1279
		1280	if (RETVAL)
		1281	RETVAL->app_private = (void *)newSVsv (ST (0));
		1282	}
		1283	OUTPUT:
		1284	RETVAL
		1285
		1286	void
		1287	db_open (DB db, DB_TXN_ornull txnid, octetstring file, octetstring database, int type, U32 flags, int mode, SV *callback = &PL_sv_undef)
		1288	CODE:
		1289	{
		1290	dREQ (REQ_DB_OPEN);
		1291	req->db = db;
		1292	req->txn = txnid;
		1293	req->buf1 = strdup_ornull (file);
		1294	req->buf2 = strdup_ornull (database);
		1295	req->int1 = type;
		1296	req->uint1 = flags \| DB_THREAD;
		1297	req->int2 = mode;
		1298	REQ_SEND;
		1299	}
		1300
		1301	void
		1302	db_close (DB db, U32 flags = 0, SV callback = &PL_sv_undef)
		1303	CODE:
		1304	{
		1305	dREQ (REQ_DB_CLOSE);
		1306	req->db = db;
		1307	req->uint1 = flags;
		1308	req->sv1 = (SV *)db->app_private;
		1309	REQ_SEND;
		1310	ptr_nuke (ST (0));
		1311	}
		1312
		1313	void
		1314	db_compact (DB db, DB_TXN_ornull txn = 0, SV start = 0, SV stop = 0, SV unused1 = 0, U32 flags = DB_FREE_SPACE, SV unused2 = 0, SV *callback = &PL_sv_undef)
		1315	CODE:
		1316	{
		1317	dREQ (REQ_DB_COMPACT);
		1318	req->db = db;
		1319	req->txn = txn;
		1320	sv_to_dbt (&req->dbt1, start);
		1321	sv_to_dbt (&req->dbt2, stop);
		1322	req->uint1 = flags;
		1323	REQ_SEND;
		1324	}
		1325
		1326	void
		1327	db_sync (DB db, U32 flags = 0, SV callback = &PL_sv_undef)
		1328	CODE:
		1329	{
		1330	dREQ (REQ_DB_SYNC);
		1331	req->db = db;
		1332	req->uint1 = flags;
		1333	REQ_SEND;
		1334	}
		1335
		1336	void
		1337	db_key_range (DB db, DB_TXN_ornull txn, SV key, SV key_range, U32 flags = 0, SV *callback = &PL_sv_undef)
		1338	CODE:
		1339	{
		1340	dREQ (REQ_DB_KEY_RANGE);
		1341	req->db = db;
		1342	req->txn = txn;
		1343	sv_to_dbt (&req->dbt1, key);
		1344	req->uint1 = flags;
		1345	req->sv1 = SvREFCNT_inc (key_range); SvREADONLY_on (key_range);
		1346	REQ_SEND;
		1347	}
		1348
		1349	void
		1350	db_put (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
		1351	CODE:
		1352	{
		1353	dREQ (REQ_DB_PUT);
		1354	req->db = db;
		1355	req->txn = txn;
		1356	sv_to_dbt (&req->dbt1, key);
		1357	sv_to_dbt (&req->dbt2, data);
		1358	req->uint1 = flags;
		1359	REQ_SEND;
		1360	}
		1361
		1362	void
		1363	db_get (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
		1364	CODE:
		1365	{
		1366	dREQ (REQ_DB_GET);
		1367	req->db = db;
		1368	req->txn = txn;
		1369	req->uint1 = flags;
		1370	sv_to_dbt (&req->dbt1, key);
		1371	req->dbt3.flags = DB_DBT_MALLOC;
		1372	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1373	REQ_SEND;
		1374	}
		1375
		1376	void
		1377	db_pget (DB db, DB_TXN_ornull txn, SV key, SV pkey, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
		1378	CODE:
		1379	{
		1380	dREQ (REQ_DB_PGET);
		1381	req->db = db;
		1382	req->txn = txn;
		1383	req->uint1 = flags;
		1384	sv_to_dbt (&req->dbt1, key);
		1385	sv_to_dbt (&req->dbt2, pkey);
		1386	req->dbt3.flags = DB_DBT_MALLOC;
		1387	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1388	REQ_SEND;
		1389	}
		1390
		1391	void
		1392	db_del (DB db, DB_TXN_ornull txn, SV key, U32 flags = 0, SV callback = &PL_sv_undef)
		1393	CODE:
		1394	{
		1395	dREQ (REQ_DB_DEL);
		1396	req->db = db;
		1397	req->txn = txn;
		1398	req->uint1 = flags;
		1399	sv_to_dbt (&req->dbt1, key);
		1400	REQ_SEND;
		1401	}
		1402
		1403	void
		1404	db_txn_commit (DB_TXN txn, U32 flags = 0, SV callback = &PL_sv_undef)
		1405	CODE:
		1406	{
		1407	dREQ (REQ_TXN_COMMIT);
		1408	req->txn = txn;
		1409	req->uint1 = flags;
		1410	REQ_SEND;
		1411	ptr_nuke (ST (0));
		1412	}
		1413
		1414	void
		1415	db_txn_abort (DB_TXN txn, SV callback = &PL_sv_undef)
		1416	CODE:
		1417	{
		1418	dREQ (REQ_TXN_ABORT);
		1419	req->txn = txn;
		1420	REQ_SEND;
		1421	ptr_nuke (ST (0));
		1422	}
		1423
		1424	void
		1425	db_c_close (DBC dbc, SV callback = &PL_sv_undef)
		1426	CODE:
		1427	{
		1428	dREQ (REQ_C_CLOSE);
		1429	req->dbc = dbc;
		1430	REQ_SEND;
		1431	ptr_nuke (ST (0));
		1432	}
		1433
		1434	void
		1435	db_c_count (DBC dbc, SV count, U32 flags = 0, SV *callback = &PL_sv_undef)
		1436	CODE:
		1437	{
		1438	dREQ (REQ_C_COUNT);
		1439	req->dbc = dbc;
		1440	req->sv1 = SvREFCNT_inc (count);
		1441	REQ_SEND;
		1442	}
		1443
		1444	void
		1445	db_c_put (DBC dbc, SV key, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
		1446	CODE:
		1447	{
		1448	dREQ (REQ_C_PUT);
		1449	req->dbc = dbc;
		1450	sv_to_dbt (&req->dbt1, key);
		1451	sv_to_dbt (&req->dbt2, data);
		1452	req->uint1 = flags;
		1453	REQ_SEND;
		1454	}
		1455
		1456	void
		1457	db_c_get (DBC dbc, SV key, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
		1458	CODE:
		1459	{
		1460	dREQ (REQ_C_GET);
		1461	req->dbc = dbc;
		1462	req->uint1 = flags;
		1463	if ((flags & DB_SET) == DB_SET
		1464	\|\| (flags & DB_SET_RANGE) == DB_SET_RANGE)
		1465	sv_to_dbt (&req->dbt1, key);
		1466	else
		1467	req->dbt1.flags = DB_DBT_MALLOC;
		1468
		1469	req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
		1470
		1471	if ((flags & DB_GET_BOTH) == DB_GET_BOTH
		1472	\|\| (flags & DB_GET_BOTH_RANGE) == DB_GET_BOTH_RANGE)
		1473	sv_to_dbt (&req->dbt3, data);
		1474	else
		1475	req->dbt3.flags = DB_DBT_MALLOC;
		1476
		1477	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1478	REQ_SEND;
		1479	}
		1480
		1481	void
		1482	db_c_pget (DBC dbc, SV key, SV pkey, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
		1483	CODE:
		1484	{
		1485	dREQ (REQ_C_PGET);
		1486	req->dbc = dbc;
		1487	req->uint1 = flags;
		1488	if ((flags & DB_SET) == DB_SET
		1489	\|\| (flags & DB_SET_RANGE) == DB_SET_RANGE)
		1490	sv_to_dbt (&req->dbt1, key);
		1491	else
		1492	req->dbt1.flags = DB_DBT_MALLOC;
		1493
		1494	req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
		1495
		1496	req->dbt2.flags = DB_DBT_MALLOC;
		1497	req->sv2 = SvREFCNT_inc (pkey); SvREADONLY_on (pkey);
		1498
		1499	if ((flags & DB_GET_BOTH) == DB_GET_BOTH
		1500	\|\| (flags & DB_GET_BOTH_RANGE) == DB_GET_BOTH_RANGE)
		1501	sv_to_dbt (&req->dbt3, data);
		1502	else
		1503	req->dbt3.flags = DB_DBT_MALLOC;
		1504
		1505	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1506	REQ_SEND;
		1507	}
		1508
		1509	void
		1510	db_c_del (DBC dbc, U32 flags = 0, SV callback = &PL_sv_undef)
		1511	CODE:
		1512	{
		1513	dREQ (REQ_C_DEL);
		1514	req->dbc = dbc;
		1515	req->uint1 = flags;
		1516	REQ_SEND;
		1517	}
		1518
		1519
		1520	void
		1521	db_sequence_open (DB_SEQUENCE seq, DB_TXN_ornull txnid, SV key, U32 flags = 0, SV callback = &PL_sv_undef)
		1522	CODE:
		1523	{
		1524	dREQ (REQ_SEQ_OPEN);
		1525	req->seq = seq;
		1526	req->txn = txnid;
		1527	req->uint1 = flags \| DB_THREAD;
		1528	sv_to_dbt (&req->dbt1, key);
		1529	REQ_SEND;
		1530	}
		1531
		1532	void
		1533	db_sequence_close (DB_SEQUENCE seq, U32 flags = 0, SV callback = &PL_sv_undef)
		1534	CODE:
		1535	{
		1536	dREQ (REQ_SEQ_CLOSE);
		1537	req->seq = seq;
		1538	req->uint1 = flags;
		1539	REQ_SEND;
		1540	ptr_nuke (ST (0));
		1541	}
		1542
		1543	void
		1544	db_sequence_get (DB_SEQUENCE seq, DB_TXN_ornull txnid, int delta, SV seq_value, U32 flags = DB_TXN_NOSYNC, SV callback = &PL_sv_undef)
		1545	CODE:
		1546	{
		1547	dREQ (REQ_SEQ_GET);
		1548	req->seq = seq;
		1549	req->txn = txnid;
		1550	req->int1 = delta;
		1551	req->uint1 = flags;
		1552	req->sv1 = SvREFCNT_inc (seq_value); SvREADONLY_on (seq_value);
		1553	REQ_SEND;
		1554	}
		1555
		1556	void
		1557	db_sequence_remove (DB_SEQUENCE seq, DB_TXN_ornull txnid = 0, U32 flags = 0, SV *callback = &PL_sv_undef)
		1558	CODE:
		1559	{
		1560	dREQ (REQ_SEQ_REMOVE);
		1561	req->seq = seq;
		1562	req->txn = txnid;
		1563	req->uint1 = flags;
		1564	REQ_SEND;
		1565	}
		1566
		1567
		1568	MODULE = BDB PACKAGE = BDB::Env
		1569
		1570	void
		1571	DESTROY (DB_ENV_ornull *env)
		1572	CODE:
		1573	if (env)
		1574	env->close (env, 0);
		1575
		1576	int set_data_dir (DB_ENV env, const char dir)
		1577	CODE:
		1578	RETVAL = env->set_data_dir (env, dir);
		1579	OUTPUT:
		1580	RETVAL
		1581
		1582	int set_tmp_dir (DB_ENV env, const char dir)
		1583	CODE:
		1584	RETVAL = env->set_tmp_dir (env, dir);
		1585	OUTPUT:
		1586	RETVAL
		1587
		1588	int set_lg_dir (DB_ENV env, const char dir)
		1589	CODE:
		1590	RETVAL = env->set_lg_dir (env, dir);
		1591	OUTPUT:
		1592	RETVAL
		1593
		1594	int set_shm_key (DB_ENV *env, long shm_key)
		1595	CODE:
		1596	RETVAL = env->set_shm_key (env, shm_key);
		1597	OUTPUT:
		1598	RETVAL
		1599
		1600	int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0)
		1601	CODE:
		1602	RETVAL = env->set_cachesize (env, gbytes, bytes, ncache);
		1603	OUTPUT:
		1604	RETVAL
		1605
		1606	int set_flags (DB_ENV *env, U32 flags, int onoff)
		1607	CODE:
		1608	RETVAL = env->set_flags (env, flags, onoff);
		1609	OUTPUT:
		1610	RETVAL
		1611
		1612	int set_encrypt (DB_ENV env, const char password, U32 flags = 0)
		1613	CODE:
		1614	RETVAL = env->set_encrypt (env, password, flags);
		1615	OUTPUT:
		1616	RETVAL
		1617
		1618	int set_timeout (DB_ENV *env, NV timeout, U32 flags)
		1619	CODE:
		1620	RETVAL = env->set_timeout (env, timeout * 1000000, flags);
		1621	OUTPUT:
		1622	RETVAL
		1623
		1624	int set_mp_max_openfd (DB_ENV *env, int maxopenfd);
		1625	CODE:
		1626	RETVAL = env->set_mp_max_openfd (env, maxopenfd);
		1627	OUTPUT:
		1628	RETVAL
		1629
		1630	int set_mp_max_write (DB_ENV *env, int maxwrite, int maxwrite_sleep);
		1631	CODE:
		1632	RETVAL = env->set_mp_max_write (env, maxwrite, maxwrite_sleep);
		1633	OUTPUT:
		1634	RETVAL
		1635
		1636	int set_mp_mmapsize (DB_ENV *env, int mmapsize_mb)
		1637	CODE:
		1638	RETVAL = env->set_mp_mmapsize (env, ((size_t)mmapsize_mb) << 20);
		1639	OUTPUT:
		1640	RETVAL
		1641
		1642	int set_lk_detect (DB_ENV *env, U32 detect = DB_LOCK_DEFAULT)
		1643	CODE:
		1644	RETVAL = env->set_lk_detect (env, detect);
		1645	OUTPUT:
		1646	RETVAL
		1647
		1648	int set_lk_max_lockers (DB_ENV *env, U32 max)
		1649	CODE:
		1650	RETVAL = env->set_lk_max_lockers (env, max);
		1651	OUTPUT:
		1652	RETVAL
		1653
		1654	int set_lk_max_locks (DB_ENV *env, U32 max)
		1655	CODE:
		1656	RETVAL = env->set_lk_max_locks (env, max);
		1657	OUTPUT:
		1658	RETVAL
		1659
		1660	int set_lk_max_objects (DB_ENV *env, U32 max)
		1661	CODE:
		1662	RETVAL = env->set_lk_max_objects (env, max);
		1663	OUTPUT:
		1664	RETVAL
		1665
		1666	int set_lg_bsize (DB_ENV *env, U32 max)
		1667	CODE:
		1668	RETVAL = env->set_lg_bsize (env, max);
		1669	OUTPUT:
		1670	RETVAL
		1671
		1672	int set_lg_max (DB_ENV *env, U32 max)
		1673	CODE:
		1674	RETVAL = env->set_lg_max (env, max);
		1675	OUTPUT:
		1676	RETVAL
		1677
		1678	DB_TXN *
		1679	txn_begin (DB_ENV env, DB_TXN_ornull parent = 0, U32 flags = 0)
		1680	CODE:
		1681	errno = env->txn_begin (env, parent, &RETVAL, flags);
		1682	if (errno)
		1683	croak ("DB_ENV->txn_begin: %s", db_strerror (errno));
		1684	OUTPUT:
		1685	RETVAL
		1686
		1687	MODULE = BDB PACKAGE = BDB::Db
		1688
		1689	void
		1690	DESTROY (DB_ornull *db)
		1691	CODE:
		1692	if (db)
		1693	{
		1694	SV env = (SV )db->app_private;
		1695	db->close (db, 0);
		1696	SvREFCNT_dec (env);
		1697	}
		1698
		1699	int set_cachesize (DB *db, U32 gbytes, U32 bytes, int ncache = 0)
		1700	CODE:
		1701	RETVAL = db->set_cachesize (db, gbytes, bytes, ncache);
		1702	OUTPUT:
		1703	RETVAL
		1704
		1705	int set_flags (DB *db, U32 flags);
		1706	CODE:
		1707	RETVAL = db->set_flags (db, flags);
		1708	OUTPUT:
		1709	RETVAL
		1710
		1711	int set_encrypt (DB db, const char password, U32 flags)
		1712	CODE:
		1713	RETVAL = db->set_encrypt (db, password, flags);
		1714	OUTPUT:
		1715	RETVAL
		1716
		1717	int set_lorder (DB *db, int lorder)
		1718	CODE:
		1719	RETVAL = db->set_lorder (db, lorder);
		1720	OUTPUT:
		1721	RETVAL
		1722
		1723	int set_bt_minkey (DB *db, U32 minkey)
		1724	CODE:
		1725	RETVAL = db->set_bt_minkey (db, minkey);
		1726	OUTPUT:
		1727	RETVAL
		1728
		1729	int set_re_delim(DB *db, int delim);
		1730	CODE:
		1731	RETVAL = db->set_re_delim (db, delim);
		1732	OUTPUT:
		1733	RETVAL
		1734
		1735	int set_re_pad (DB *db, int re_pad)
		1736	CODE:
		1737	RETVAL = db->set_re_pad (db, re_pad);
		1738	OUTPUT:
		1739	RETVAL
		1740
		1741	int set_re_source (DB db, char source)
		1742	CODE:
		1743	RETVAL = db->set_re_source (db, source);
		1744	OUTPUT:
		1745	RETVAL
		1746
		1747	int set_re_len (DB *db, U32 re_len)
		1748	CODE:
		1749	RETVAL = db->set_re_len (db, re_len);
		1750	OUTPUT:
		1751	RETVAL
		1752
		1753	int set_h_ffactor (DB *db, U32 h_ffactor)
		1754	CODE:
		1755	RETVAL = db->set_h_ffactor (db, h_ffactor);
		1756	OUTPUT:
		1757	RETVAL
		1758
		1759	int set_h_nelem (DB *db, U32 h_nelem)
		1760	CODE:
		1761	RETVAL = db->set_h_nelem (db, h_nelem);
		1762	OUTPUT:
		1763	RETVAL
		1764
		1765	int set_q_extentsize (DB *db, U32 extentsize)
		1766	CODE:
		1767	RETVAL = db->set_q_extentsize (db, extentsize);
		1768	OUTPUT:
		1769	RETVAL
		1770
		1771	DBC *
		1772	cursor (DB db, DB_TXN_ornull txn = 0, U32 flags = 0)
		1773	CODE:
		1774	errno = db->cursor (db, txn, &RETVAL, flags);
		1775	if (errno)
		1776	croak ("DB->cursor: %s", db_strerror (errno));
		1777	OUTPUT:
		1778	RETVAL
		1779
		1780	DB_SEQUENCE *
		1781	sequence (DB *db, U32 flags = 0)
		1782	CODE:
		1783	{
		1784	errno = db_sequence_create (&RETVAL, db, flags);
		1785	if (errno)
		1786	croak ("db_sequence_create: %s", db_strerror (errno));
		1787	}
		1788	OUTPUT:
		1789	RETVAL
		1790
		1791
		1792	MODULE = BDB PACKAGE = BDB::Txn
		1793
		1794	void
		1795	DESTROY (DB_TXN_ornull *txn)
		1796	CODE:
		1797	if (txn)
		1798	txn->abort (txn);
		1799
		1800	int set_timeout (DB_TXN *txn, NV timeout, U32 flags)
		1801	CODE:
		1802	RETVAL = txn->set_timeout (txn, timeout * 1000000, flags);
		1803	OUTPUT:
		1804	RETVAL
		1805
		1806
		1807	MODULE = BDB PACKAGE = BDB::Cursor
		1808
		1809	void
		1810	DESTROY (DBC_ornull *dbc)
		1811	CODE:
		1812	if (dbc)
		1813	dbc->c_close (dbc);
		1814
		1815	MODULE = BDB PACKAGE = BDB::Sequence
		1816
		1817	void
		1818	DESTROY (DB_SEQUENCE_ornull *seq)
		1819	CODE:
		1820	if (seq)
		1821	seq->close (seq, 0);
		1822
		1823	int initial_value (DB_SEQUENCE *seq, db_seq_t value)
		1824	CODE:
		1825	RETVAL = seq->initial_value (seq, value);
		1826	OUTPUT:
		1827	RETVAL
		1828
		1829	int set_cachesize (DB_SEQUENCE *seq, U32 size)
		1830	CODE:
		1831	RETVAL = seq->set_cachesize (seq, size);
		1832	OUTPUT:
		1833	RETVAL
		1834
		1835	int set_flags (DB_SEQUENCE *seq, U32 flags)
		1836	CODE:
		1837	RETVAL = seq->set_flags (seq, flags);
		1838	OUTPUT:
		1839	RETVAL
		1840
		1841	int set_range (DB_SEQUENCE *seq, db_seq_t min, db_seq_t max)
		1842	CODE:
		1843	RETVAL = seq->set_range (seq, min, max);
		1844	OUTPUT:
		1845	RETVAL
		1846

Diff Legend

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

Comparing BDB/BDB.xs (file contents): Revision 1.1 by root, Mon Feb 5 18:40:55 2007 UTC vs. Revision 1.10 by root, Mon Mar 5 19:47:01 2007 UTC

Diff Legend

Comparing BDB/BDB.xs (file contents):
Revision 1.1 by root, Mon Feb 5 18:40:55 2007 UTC vs.
Revision 1.10 by root, Mon Mar 5 19:47:01 2007 UTC