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

Comparing BDB/BDB.xs (file contents):
Revision 1.2 by root, Mon Feb 5 20:21:38 2007 UTC vs.
Revision 1.9 by root, Sun Feb 11 22:38:37 2007 UTC

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

Diff Legend

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

Comparing BDB/BDB.xs (file contents): Revision 1.2 by root, Mon Feb 5 20:21:38 2007 UTC vs. Revision 1.9 by root, Sun Feb 11 22:38:37 2007 UTC

Diff Legend

Comparing BDB/BDB.xs (file contents):
Revision 1.2 by root, Mon Feb 5 20:21:38 2007 UTC vs.
Revision 1.9 by root, Sun Feb 11 22:38:37 2007 UTC