[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.6 by root, Tue Feb 6 01:09:04 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
45	typedef SV SV8; /* byte-sv, used for argument-checking */	50	typedef SV SV8; /* byte-sv, used for argument-checking */
		51	typedef char *octetstring;
46		52
		53	static SV *prepare_cb;
		54
		55	static inline char *
		56	strdup_ornull (const char *s)
		57	{
		58	return s ? strdup (s) : 0;
		59	}
		60
		61	static inline void
		62	sv_to_dbt (DBT dbt, SV sv)
		63	{
		64	STRLEN len;
		65	char *data = SvPVbyte (sv, len);
		66
		67	dbt->data = malloc (len);
		68	memcpy (dbt->data, data, len);
		69	dbt->size = len;
		70	dbt->flags = DB_DBT_REALLOC;
		71	}
		72
		73	static inline void
		74	dbt_to_sv (SV sv, DBT dbt)
		75	{
		76	if (sv)
		77	{
		78	SvREADONLY_off (sv);
		79	sv_setpvn_mg (sv, dbt->data, dbt->size);
		80	SvREFCNT_dec (sv);
		81	}
		82
		83	free (dbt->data);
		84	}
		85
47	enum	86	enum {
48	{
49	REQ_QUIT,	87	REQ_QUIT,
50	REQ_ENV_OPEN, REQ_ENV_CLOSE,	88	REQ_ENV_OPEN, REQ_ENV_CLOSE,
51	REQ_DB_OPEN, REQ_DB_CLOSE,	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,
		90	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,
52	};	92	};
53		93
54	typedef struct aio_cb	94	typedef struct aio_cb
55	{	95	{
56	struct aio_cb *volatile next;	96	struct aio_cb *volatile next;
57	SV *callback;	97	SV *callback;
58	int type, pri, errorno;	98	int type, pri, result;
59		99
60	DB_ENV *env;	100	DB_ENV *env;
61	DB *db;	101	DB *db;
62	DB_TXN *txn;	102	DB_TXN *txn;
63	DBC *cursor;	103	DBC *dbc;
		104
		105	UV uv1;
64	int int1, int2;	106	int int1, int2;
65	U32 uint1, uint2;	107	U32 uint1, uint2;
66	char buf1, buf2;	108	char buf1, buf2;
		109	SV sv1, sv2, *sv3;
		110
		111	DBT dbt1, dbt2, dbt3;
67	} aio_cb;	112	} aio_cb;
68		113
69	typedef aio_cb *aio_req;	114	typedef aio_cb *aio_req;
70		115
71	enum {	116	enum {
…		…
252	PUSHMARK (SP);	297	PUSHMARK (SP);
253	EXTEND (SP, 1);	298	EXTEND (SP, 1);
254		299
255	switch (req->type)	300	switch (req->type)
256	{	301	{
		302	case REQ_DB_CLOSE:
		303	SvREFCNT_dec (req->sv1);
		304	break;
		305
		306	case REQ_DB_GET:
		307	case REQ_DB_PGET:
		308	dbt_to_sv (req->sv3, &req->dbt3);
		309	break;
		310
		311	case REQ_C_GET:
		312	case REQ_C_PGET:
		313	dbt_to_sv (req->sv1, &req->dbt1);
		314	dbt_to_sv (req->sv2, &req->dbt2);
		315	dbt_to_sv (req->sv3, &req->dbt3);
		316	break;
257	}	317	}
		318
		319	errno = req->result;
258		320
259	PUTBACK;	321	PUTBACK;
260	call_sv (req->callback, G_VOID \| G_EVAL);	322	call_sv (req->callback, G_VOID \| G_EVAL);
261	SPAGAIN;	323	SPAGAIN;
262		324
…		…
272	free (req->buf1);	334	free (req->buf1);
273	free (req->buf2);	335	free (req->buf2);
274	Safefree (req);	336	Safefree (req);
275	}	337	}
276		338
277	static void aio_proc(void arg);	339	static void aio_proc (void arg);
278		340
279	static void start_thread (void)	341	static void start_thread (void)
280	{	342	{
281	sigset_t fullsigset, oldsigset;	343	sigset_t fullsigset, oldsigset;
282	pthread_attr_t attr;	344	pthread_attr_t attr;
…		…
324	start_thread ();	386	start_thread ();
325	}	387	}
326		388
327	static void req_send (aio_req req)	389	static void req_send (aio_req req)
328	{	390	{
		391	SV *wait_callback = 0;
		392
		393	// synthesize callback if none given
		394	if (!SvOK (req->callback))
		395	{
		396	dSP;
		397	PUSHMARK (SP);
		398	PUTBACK;
		399	int count = call_sv (prepare_cb, G_ARRAY);
		400	SPAGAIN;
		401
		402	if (count != 2)
		403	croak ("prepare callback must return exactly two values\n");
		404
		405	wait_callback = SvREFCNT_inc (POPs);
		406	SvREFCNT_dec (req->callback);
		407	req->callback = SvREFCNT_inc (POPs);
		408	}
		409
329	++nreqs;	410	++nreqs;
330		411
331	LOCK (reqlock);	412	LOCK (reqlock);
332	++nready;	413	++nready;
333	reqq_push (&req_queue, req);	414	reqq_push (&req_queue, req);
334	pthread_cond_signal (&reqwait);	415	pthread_cond_signal (&reqwait);
335	UNLOCK (reqlock);	416	UNLOCK (reqlock);
336		417
337	maybe_start_thread ();	418	maybe_start_thread ();
		419
		420	if (wait_callback)
		421	{
		422	dSP;
		423	PUSHMARK (SP);
		424	PUTBACK;
		425	call_sv (wait_callback, G_DISCARD);
		426	SvREFCNT_dec (wait_callback);
		427	}
338	}	428	}
339		429
340	static void end_thread (void)	430	static void end_thread (void)
341	{	431	{
342	aio_req req;	432	aio_req req;
…		…
537		627
538	--nready;	628	--nready;
539		629
540	UNLOCK (reqlock);	630	UNLOCK (reqlock);
541		631
542	errno = 0; /* strictly unnecessary */
543
544	switch (req->type)	632	switch (req->type)
545	{	633	{
546	case REQ_QUIT:	634	case REQ_QUIT:
547	goto quit;	635	goto quit;
548		636
		637	case REQ_ENV_OPEN:
		638	req->result = req->env->open (req->env, req->buf1, req->uint1, req->int1);
		639	break;
		640
		641	case REQ_ENV_CLOSE:
		642	req->result = req->env->close (req->env, req->uint1);
		643	break;
		644
		645	case REQ_DB_OPEN:
		646	req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
		647	break;
		648
		649	case REQ_DB_CLOSE:
		650	req->result = req->db->close (req->db, req->uint1);
		651	break;
		652
		653	case REQ_DB_COMPACT:
		654	req->result = req->db->compact (req->db, req->txn, &req->dbt1, &req->dbt2, 0, req->uint1, 0);
		655	break;
		656
		657	case REQ_DB_SYNC:
		658	req->result = req->db->sync (req->db, req->uint1);
		659	break;
		660
		661	case REQ_DB_PUT:
		662	req->result = req->db->put (req->db, req->txn, &req->dbt1, &req->dbt2, req->uint1);
		663	break;
		664
		665	case REQ_DB_GET:
		666	req->result = req->db->get (req->db, req->txn, &req->dbt1, &req->dbt3, req->uint1);
		667	break;
		668
		669	case REQ_DB_PGET:
		670	req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
		671	break;
		672
		673	case REQ_DB_DEL:
		674	req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);
		675	break;
		676
		677	case REQ_TXN_COMMIT:
		678	req->result = req->txn->commit (req->txn, req->uint1);
		679	break;
		680
		681	case REQ_TXN_ABORT:
		682	req->result = req->txn->abort (req->txn);
		683	break;
		684
		685	case REQ_C_CLOSE:
		686	req->result = req->dbc->c_close (req->dbc);
		687	break;
		688
		689	case REQ_C_COUNT:
		690	{
		691	db_recno_t recno;
		692	req->result = req->dbc->c_count (req->dbc, &recno, req->uint1);
		693	req->uv1 = recno;
		694	}
		695	break;
		696
		697	case REQ_C_PUT:
		698	req->result = req->dbc->c_put (req->dbc, &req->dbt1, &req->dbt2, req->uint1);
		699	break;
		700
		701	case REQ_C_GET:
		702	req->result = req->dbc->c_get (req->dbc, &req->dbt1, &req->dbt3, req->uint1);
		703	break;
		704
		705	case REQ_C_PGET:
		706	req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
		707	break;
		708
		709	case REQ_C_DEL:
		710	req->result = req->dbc->c_del (req->dbc, req->uint1);
		711	break;
		712
549	default:	713	default:
550	//req->result = ENOSYS;	714	req->result = ENOSYS;
551	break;	715	break;
552	}	716	}
553
554	//req->errorno = errno;
555		717
556	LOCK (reslock);	718	LOCK (reslock);
557		719
558	++npending;	720	++npending;
559		721
…		…
642	req->pri = req_pri	804	req->pri = req_pri
643		805
644	#define REQ_SEND \	806	#define REQ_SEND \
645	req_send (req)	807	req_send (req)
646		808
647	#define SvPTR(var, arg, type, class) \	809	#define SvPTR(var, arg, type, class, nullok) \
648	if (!SvOK (arg)) \	810	if (!SvOK (arg)) \
		811	{ \
		812	if (!nullok) \
		813	Perl_croak (# var " must be a " # class " object, not undef"); \
		814	\
649	(var) = 0; \	815	(var) = 0; \
		816	} \
650	else if (sv_derived_from ((arg), # class)) \	817	else if (sv_derived_from ((arg), # class)) \
651	{ \	818	{ \
652	IV tmp = SvIV ((SV*) SvRV (arg)); \	819	IV tmp = SvIV ((SV*) SvRV (arg)); \
653	(var) = INT2PTR (type, tmp); \	820	(var) = INT2PTR (type, tmp); \
		821	if (!var) \
		822	Perl_croak (# var " is not a valid " # class " object anymore"); \
654	} \	823	} \
655	else \	824	else \
656	Perl_croak (# var " is not of type " # type)	825	Perl_croak (# var " is not of type " # class); \
657		826	\
		827
		828	static void
		829	ptr_nuke (SV *sv)
		830	{
		831	assert (SvROK (sv));
		832	sv_setiv (SvRV (sv), 0);
		833	}
		834
658	MODULE = BDB PACKAGE = BDB	835	MODULE = BDB PACKAGE = BDB
659		836
660	PROTOTYPES: ENABLE	837	PROTOTYPES: ENABLE
661		838
662	BOOT:	839	BOOT:
…		…
702	const_iv (REGION_INIT)	879	const_iv (REGION_INIT)
703	const_iv (TIME_NOTGRANTED)	880	const_iv (TIME_NOTGRANTED)
704	const_iv (TXN_NOSYNC)	881	const_iv (TXN_NOSYNC)
705	const_iv (TXN_SNAPSHOT)	882	const_iv (TXN_SNAPSHOT)
706	const_iv (TXN_WRITE_NOSYNC)	883	const_iv (TXN_WRITE_NOSYNC)
		884	const_iv (WRITECURSOR)
707	const_iv (YIELDCPU)	885	const_iv (YIELDCPU)
708	const_iv (ENCRYPT_AES)	886	const_iv (ENCRYPT_AES)
709	const_iv (XA_CREATE)	887	const_iv (XA_CREATE)
710	const_iv (BTREE)	888	const_iv (BTREE)
711	const_iv (HASH)	889	const_iv (HASH)
712	const_iv (QUEUE)	890	const_iv (QUEUE)
713	const_iv (RECNO)	891	const_iv (RECNO)
714	const_iv (UNKNOWN)	892	const_iv (UNKNOWN)
715	const_iv (EXCL)	893	const_iv (EXCL)
		894	const_iv (READ_COMMITTED)
716	const_iv (READ_UNCOMMITTED)	895	const_iv (READ_UNCOMMITTED)
717	const_iv (TRUNCATE)	896	const_iv (TRUNCATE)
718	const_iv (NOSYNC)	897	const_iv (NOSYNC)
719	const_iv (CHKSUM)	898	const_iv (CHKSUM)
720	const_iv (ENCRYPT)	899	const_iv (ENCRYPT)
…		…
725	const_iv (RENUMBER)	904	const_iv (RENUMBER)
726	const_iv (REVSPLITOFF)	905	const_iv (REVSPLITOFF)
727	const_iv (INORDER)	906	const_iv (INORDER)
728	const_iv (CONSUME)	907	const_iv (CONSUME)
729	const_iv (CONSUME_WAIT)	908	const_iv (CONSUME_WAIT)
		909	const_iv (GET_BOTH)
		910	const_iv (GET_BOTH_RANGE)
		911	//const_iv (SET_RECNO)
		912	//const_iv (MULTIPLE)
730	const_iv (SNAPSHOT)	913	const_iv (SNAPSHOT)
731	const_iv (JOIN_ITEM)	914	const_iv (JOIN_ITEM)
732	const_iv (RMW)	915	const_iv (RMW)
733		916
734	const_iv (NOTFOUND)	917	const_iv (NOTFOUND)
735	const_iv (KEYEMPTY)	918	const_iv (KEYEMPTY)
736	const_iv (LOCK_DEADLOCK)	919	const_iv (LOCK_DEADLOCK)
737	const_iv (LOCK_NOTGRANTED)	920	const_iv (LOCK_NOTGRANTED)
738	const_iv (RUNRECOVERY)	921	const_iv (RUNRECOVERY)
		922	const_iv (OLD_VERSION)
		923	const_iv (REP_HANDLE_DEAD)
		924	const_iv (REP_LOCKOUT)
		925	const_iv (SECONDARY_BAD)
		926
		927	const_iv (FREE_SPACE)
		928	const_iv (FREELIST_ONLY)
		929
		930	const_iv (APPEND)
		931	const_iv (NODUPDATA)
		932	const_iv (NOOVERWRITE)
		933
		934	const_iv (TXN_NOWAIT)
		935	const_iv (TXN_SNAPSHOT)
		936	const_iv (TXN_SYNC)
		937
		938	const_iv (SET_LOCK_TIMEOUT)
		939	const_iv (SET_TXN_TIMEOUT)
		940
		941	const_iv (JOIN_ITEM)
		942	const_iv (FIRST)
		943	const_iv (NEXT)
		944	const_iv (NEXT_DUP)
		945	const_iv (NEXT_NODUP)
		946	const_iv (PREV)
		947	const_iv (PREV_NODUP)
		948	const_iv (SET)
		949	const_iv (SET_RANGE)
		950	const_iv (LAST)
		951	const_iv (BEFORE)
		952	const_iv (AFTER)
		953	const_iv (CURRENT)
		954	const_iv (KEYFIRST)
		955	const_iv (KEYLAST)
		956	const_iv (NODUPDATA)
739	};	957	};
740		958
741	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	959	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
742	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	960	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
743		961
…		…
779	max_outstanding = maxreqs;	997	max_outstanding = maxreqs;
780	OUTPUT:	998	OUTPUT:
781	RETVAL	999	RETVAL
782		1000
783	int	1001	int
784	bdbreq_pri (int pri = 0)	1002	dbreq_pri (int pri = 0)
785	PROTOTYPE: ;$	1003	PROTOTYPE: ;$
786	CODE:	1004	CODE:
787	RETVAL = next_pri - PRI_BIAS;	1005	RETVAL = next_pri - PRI_BIAS;
788	if (items > 0)	1006	if (items > 0)
789	{	1007	{
…		…
793	}	1011	}
794	OUTPUT:	1012	OUTPUT:
795	RETVAL	1013	RETVAL
796		1014
797	void	1015	void
798	bdbreq_nice (int nice = 0)	1016	dbreq_nice (int nice = 0)
799	CODE:	1017	CODE:
800	nice = next_pri - nice;	1018	nice = next_pri - nice;
801	if (nice < PRI_MIN) nice = PRI_MIN;	1019	if (nice < PRI_MIN) nice = PRI_MIN;
802	if (nice > PRI_MAX) nice = PRI_MAX;	1020	if (nice > PRI_MAX) nice = PRI_MAX;
803	next_pri = nice + PRI_BIAS;	1021	next_pri = nice + PRI_BIAS;
…		…
811	poll_wait ();	1029	poll_wait ();
812	poll_cb ();	1030	poll_cb ();
813	}	1031	}
814		1032
815	int	1033	int
816	poll()	1034	poll ()
817	PROTOTYPE:	1035	PROTOTYPE:
818	CODE:	1036	CODE:
819	poll_wait ();	1037	poll_wait ();
820	RETVAL = poll_cb ();	1038	RETVAL = poll_cb ();
821	OUTPUT:	1039	OUTPUT:
822	RETVAL	1040	RETVAL
823		1041
824	int	1042	int
825	poll_fileno()	1043	poll_fileno ()
826	PROTOTYPE:	1044	PROTOTYPE:
827	CODE:	1045	CODE:
828	RETVAL = respipe [0];	1046	RETVAL = respipe [0];
829	OUTPUT:	1047	OUTPUT:
830	RETVAL	1048	RETVAL
831		1049
832	int	1050	int
833	poll_cb(...)	1051	poll_cb (...)
834	PROTOTYPE:	1052	PROTOTYPE:
835	CODE:	1053	CODE:
836	RETVAL = poll_cb ();	1054	RETVAL = poll_cb ();
837	OUTPUT:	1055	OUTPUT:
838	RETVAL	1056	RETVAL
839		1057
840	void	1058	void
841	poll_wait()	1059	poll_wait ()
842	PROTOTYPE:	1060	PROTOTYPE:
843	CODE:	1061	CODE:
844	poll_wait ();	1062	poll_wait ();
845		1063
846	int	1064	int
847	nreqs()	1065	nreqs ()
848	PROTOTYPE:	1066	PROTOTYPE:
849	CODE:	1067	CODE:
850	RETVAL = nreqs;	1068	RETVAL = nreqs;
851	OUTPUT:	1069	OUTPUT:
852	RETVAL	1070	RETVAL
853		1071
854	int	1072	int
855	nready()	1073	nready ()
856	PROTOTYPE:	1074	PROTOTYPE:
857	CODE:	1075	CODE:
858	RETVAL = get_nready ();	1076	RETVAL = get_nready ();
859	OUTPUT:	1077	OUTPUT:
860	RETVAL	1078	RETVAL
861		1079
862	int	1080	int
863	npending()	1081	npending ()
864	PROTOTYPE:	1082	PROTOTYPE:
865	CODE:	1083	CODE:
866	RETVAL = get_npending ();	1084	RETVAL = get_npending ();
867	OUTPUT:	1085	OUTPUT:
868	RETVAL	1086	RETVAL
869		1087
870	int	1088	int
871	nthreads()	1089	nthreads ()
872	PROTOTYPE:	1090	PROTOTYPE:
873	CODE:	1091	CODE:
874	if (WORDACCESS_UNSAFE) LOCK (wrklock);	1092	if (WORDACCESS_UNSAFE) LOCK (wrklock);
875	RETVAL = started;	1093	RETVAL = started;
876	if (WORDACCESS_UNSAFE) UNLOCK (wrklock);	1094	if (WORDACCESS_UNSAFE) UNLOCK (wrklock);
877	OUTPUT:	1095	OUTPUT:
878	RETVAL	1096	RETVAL
879		1097
		1098	void
		1099	set_sync_prepare (SV *cb)
		1100	PROTOTYPE: &
		1101	CODE:
		1102	SvREFCNT_dec (prepare_cb);
		1103	prepare_cb = newSVsv (cb);
		1104
880	DB_ENV *	1105	DB_ENV *
881	bdb_env_create (U32 env_flags = 0)	1106	db_env_create (U32 env_flags = 0)
882	CODE:	1107	CODE:
883	{	1108	{
884	int err = db_env_create (&RETVAL, env_flags);	1109	errno = db_env_create (&RETVAL, env_flags);
885	if (err)	1110	if (errno)
886	croak ("db_env_create: %s", db_strerror (err));	1111	croak ("db_env_create: %s", db_strerror (errno));
887	}	1112	}
		1113	OUTPUT:
		1114	RETVAL
888		1115
889	void	1116	void
890	bdb_env_open (DB_ENV env, char db_home, U32 open_flags, int mode, SV *callback = 0)	1117	db_env_open (DB_ENV env, octetstring db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)
891	CODE:	1118	CODE:
892	{	1119	{
893	dREQ (REQ_ENV_OPEN);	1120	dREQ (REQ_ENV_OPEN);
894	req->env = env;	1121	req->env = env;
895	req->uint1 = open_flags;	1122	req->uint1 = open_flags \| DB_THREAD;
896	req->int1 = mode;	1123	req->int1 = mode;
897	req->buf1 = strdup (db_home);	1124	req->buf1 = strdup_ornull (db_home);
898	REQ_SEND;	1125	REQ_SEND;
899	}	1126	}
900		1127
901	void	1128	void
902	bdb_env_close (DB_ENV env, U32 flags = 0, SV callback = 0)	1129	db_env_close (DB_ENV env, U32 flags = 0, SV callback = &PL_sv_undef)
903	CODE:	1130	CODE:
904	{	1131	{
905	dREQ (REQ_ENV_CLOSE);	1132	dREQ (REQ_ENV_CLOSE);
906	req->env = env;	1133	req->env = env;
907	req->uint1 = flags;	1134	req->uint1 = flags;
908	REQ_SEND;	1135	REQ_SEND;
		1136	ptr_nuke (ST (0));
909	}	1137	}
910		1138
911	DB *	1139	DB *
912	bdb_db_create (DB_ENV *env = 0, U32 flags = 0)	1140	db_create (DB_ENV *env = 0, U32 flags = 0)
913	CODE:	1141	CODE:
914	{	1142	{
915	int err = db_create (&RETVAL, env, flags);	1143	errno = db_create (&RETVAL, env, flags);
916	if (err)	1144	if (errno)
917	croak ("db_env_create: %s", db_strerror (err));	1145	croak ("db_create: %s", db_strerror (errno));
918	}
919		1146
		1147	if (RETVAL)
		1148	RETVAL->app_private = (void *)newSVsv (ST (0));
		1149	}
		1150	OUTPUT:
		1151	RETVAL
		1152
920	void	1153	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)	1154	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:	1155	CODE:
923	{	1156	{
924	dREQ (REQ_DB_OPEN);	1157	dREQ (REQ_DB_OPEN);
925	req->db = db;	1158	req->db = db;
926	req->txn = txnid;	1159	req->txn = txnid;
927	req->buf1 = strdup (file);	1160	req->buf1 = strdup_ornull (file);
928	req->buf2 = strdup (database);	1161	req->buf2 = strdup_ornull (database);
929	req->int1 = type;	1162	req->int1 = type;
930	req->uint1 = flags;	1163	req->uint1 = flags \| DB_THREAD;
931	req->int2 = mode;	1164	req->int2 = mode;
932	REQ_SEND;	1165	REQ_SEND;
933	}	1166	}
934		1167
935	void	1168	void
936	bdb_db_close (DB db, U32 flags = 0, SV callback = 0)	1169	db_close (DB db, U32 flags = 0, SV callback = &PL_sv_undef)
937	CODE:	1170	CODE:
938	{	1171	{
939	dREQ (REQ_DB_CLOSE);	1172	dREQ (REQ_DB_CLOSE);
940	req->db = db;	1173	req->db = db;
941	req->uint1 = flags;	1174	req->uint1 = flags;
		1175	req->sv1 = (SV *)db->app_private;
		1176	REQ_SEND;
		1177	ptr_nuke (ST (0));
		1178	}
		1179
		1180	void
		1181	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)
		1182	CODE:
		1183	{
		1184	dREQ (REQ_DB_COMPACT);
		1185	req->db = db;
		1186	req->txn = txn;
		1187	sv_to_dbt (&req->dbt1, start);
		1188	sv_to_dbt (&req->dbt2, stop);
		1189	req->uint1 = flags;
		1190	REQ_SEND;
		1191	}
		1192
		1193	void
		1194	db_sync (DB db, U32 flags = 0, SV callback = &PL_sv_undef)
		1195	CODE:
		1196	{
		1197	dREQ (REQ_DB_SYNC);
		1198	req->db = db;
		1199	req->uint1 = flags;
		1200	REQ_SEND;
		1201	}
		1202
		1203	void
		1204	db_put (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
		1205	CODE:
		1206	{
		1207	dREQ (REQ_DB_PUT);
		1208	req->db = db;
		1209	req->txn = txn;
		1210	sv_to_dbt (&req->dbt1, key);
		1211	sv_to_dbt (&req->dbt2, data);
		1212	req->uint1 = flags;
		1213	REQ_SEND;
		1214	}
		1215
		1216	void
		1217	db_get (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
		1218	CODE:
		1219	{
		1220	dREQ (REQ_DB_GET);
		1221	req->db = db;
		1222	req->txn = txn;
		1223	req->uint1 = flags;
		1224	sv_to_dbt (&req->dbt1, key);
		1225	req->dbt3.flags = DB_DBT_MALLOC;
		1226	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1227	REQ_SEND;
		1228	}
		1229
		1230	void
		1231	db_pget (DB db, DB_TXN_ornull txn, SV key, SV pkey, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
		1232	CODE:
		1233	{
		1234	dREQ (REQ_DB_PGET);
		1235	req->db = db;
		1236	req->txn = txn;
		1237	req->uint1 = flags;
		1238	sv_to_dbt (&req->dbt1, key);
		1239	sv_to_dbt (&req->dbt2, pkey);
		1240	req->dbt3.flags = DB_DBT_MALLOC;
		1241	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1242	REQ_SEND;
		1243	}
		1244
		1245	void
		1246	db_del (DB db, DB_TXN_ornull txn, SV key, U32 flags = 0, SV callback = &PL_sv_undef)
		1247	CODE:
		1248	{
		1249	dREQ (REQ_DB_DEL);
		1250	req->db = db;
		1251	req->txn = txn;
		1252	req->uint1 = flags;
		1253	sv_to_dbt (&req->dbt1, key);
		1254	REQ_SEND;
		1255	}
		1256
		1257	void
		1258	db_txn_commit (DB_TXN txn, U32 flags = 0, SV callback = &PL_sv_undef)
		1259	CODE:
		1260	{
		1261	dREQ (REQ_TXN_COMMIT);
		1262	req->txn = txn;
		1263	req->uint1 = flags;
		1264	REQ_SEND;
		1265	ptr_nuke (ST (0));
		1266	}
		1267
		1268	void
		1269	db_txn_abort (DB_TXN txn, SV callback = &PL_sv_undef)
		1270	CODE:
		1271	{
		1272	dREQ (REQ_TXN_ABORT);
		1273	req->txn = txn;
		1274	REQ_SEND;
		1275	ptr_nuke (ST (0));
		1276	}
		1277
		1278	void
		1279	db_c_close (DBC dbc, SV callback = &PL_sv_undef)
		1280	CODE:
		1281	{
		1282	dREQ (REQ_C_CLOSE);
		1283	req->dbc = dbc;
		1284	REQ_SEND;
		1285	ptr_nuke (ST (0));
		1286	}
		1287
		1288	void
		1289	db_c_count (DBC dbc, SV count, U32 flags = 0, SV *callback = &PL_sv_undef)
		1290	CODE:
		1291	{
		1292	dREQ (REQ_C_COUNT);
		1293	req->dbc = dbc;
		1294	req->sv1 = SvREFCNT_inc (count);
		1295	REQ_SEND;
		1296	}
		1297
		1298	void
		1299	db_c_put (DBC dbc, SV key, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
		1300	CODE:
		1301	{
		1302	dREQ (REQ_C_PUT);
		1303	req->dbc = dbc;
		1304	sv_to_dbt (&req->dbt1, key);
		1305	sv_to_dbt (&req->dbt2, data);
		1306	req->uint1 = flags;
		1307	REQ_SEND;
		1308	}
		1309
		1310	void
		1311	db_c_get (DBC dbc, SV key, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
		1312	CODE:
		1313	{
		1314	dREQ (REQ_C_GET);
		1315	req->dbc = dbc;
		1316	req->uint1 = flags;
		1317	if ((flags & DB_SET) == DB_SET
		1318	\|\| (flags & DB_SET_RANGE) == DB_SET_RANGE)
		1319	sv_to_dbt (&req->dbt1, key);
		1320	else
		1321	req->dbt1.flags = DB_DBT_MALLOC;
		1322
		1323	req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
		1324
		1325	if ((flags & DB_GET_BOTH) == DB_GET_BOTH
		1326	\|\| (flags & DB_GET_BOTH_RANGE) == DB_GET_BOTH_RANGE)
		1327	sv_to_dbt (&req->dbt3, data);
		1328	else
		1329	req->dbt3.flags = DB_DBT_MALLOC;
		1330
		1331	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1332	REQ_SEND;
		1333	}
		1334
		1335	void
		1336	db_c_pget (DBC dbc, SV key, SV pkey, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
		1337	CODE:
		1338	{
		1339	dREQ (REQ_C_PGET);
		1340	req->dbc = dbc;
		1341	req->uint1 = flags;
		1342	if ((flags & DB_SET) == DB_SET
		1343	\|\| (flags & DB_SET_RANGE) == DB_SET_RANGE)
		1344	sv_to_dbt (&req->dbt1, key);
		1345	else
		1346	req->dbt1.flags = DB_DBT_MALLOC;
		1347
		1348	req->sv1 = SvREFCNT_inc (key); SvREADONLY_on (key);
		1349
		1350	req->dbt2.flags = DB_DBT_MALLOC;
		1351	req->sv2 = SvREFCNT_inc (pkey); SvREADONLY_on (pkey);
		1352
		1353	if ((flags & DB_GET_BOTH) == DB_GET_BOTH
		1354	\|\| (flags & DB_GET_BOTH_RANGE) == DB_GET_BOTH_RANGE)
		1355	sv_to_dbt (&req->dbt3, data);
		1356	else
		1357	req->dbt3.flags = DB_DBT_MALLOC;
		1358
		1359	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
		1360	REQ_SEND;
		1361	}
		1362
		1363	void
		1364	db_c_del (DBC dbc, U32 flags = 0, SV callback = &PL_sv_undef)
		1365	CODE:
		1366	{
		1367	dREQ (REQ_C_DEL);
		1368	req->dbc = dbc;
		1369	req->uint1 = flags;
942	REQ_SEND;	1370	REQ_SEND;
943	}	1371	}
944		1372
945		1373
946	MODULE = BDB PACKAGE = BDB::Env	1374	MODULE = BDB PACKAGE = BDB::Env
947		1375
		1376	void
		1377	DESTROY (DB_ENV_ornull *env)
		1378	CODE:
		1379	if (env)
		1380	env->close (env, 0);
		1381
948	int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0)	1382	int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0)
		1383	CODE:
		1384	RETVAL = env->set_cachesize (env, gbytes, bytes, ncache);
		1385	OUTPUT:
		1386	RETVAL
949		1387
950	int set_flags (DB_ENV *env, U32 flags, int onoff)	1388	int set_flags (DB_ENV *env, U32 flags, int onoff)
		1389	CODE:
		1390	RETVAL = env->set_flags (env, flags, onoff);
		1391	OUTPUT:
		1392	RETVAL
951		1393
952	int set_encrypt (DB_ENV env, const char password, U32 flags)	1394	int set_encrypt (DB_ENV env, const char password, U32 flags = 0)
		1395	CODE:
		1396	RETVAL = env->set_encrypt (env, password, flags);
		1397	OUTPUT:
		1398	RETVAL
		1399
		1400	int set_timeout (DB_ENV *env, NV timeout, U32 flags)
		1401	CODE:
		1402	RETVAL = env->set_timeout (env, timeout * 1000000, flags);
		1403	OUTPUT:
		1404	RETVAL
		1405
		1406	DB_TXN *
		1407	txn_begin (DB_ENV env, DB_TXN_ornull parent = 0, U32 flags = 0)
		1408	CODE:
		1409	errno = env->txn_begin (env, parent, &RETVAL, flags);
		1410	if (errno)
		1411	croak ("DB_ENV->txn_begin: %s", db_strerror (errno));
		1412	OUTPUT:
		1413	RETVAL
953		1414
954	MODULE = BDB PACKAGE = BDB::Db	1415	MODULE = BDB PACKAGE = BDB::Db
955		1416
		1417	void
		1418	DESTROY (DB_ornull *db)
		1419	CODE:
		1420	if (db)
		1421	{
		1422	SV env = (SV )db->app_private;
		1423	db->close (db, 0);
		1424	SvREFCNT_dec (env);
		1425	}
		1426
956	int set_cachesize (DB *db, U32 gbytes, U32 bytes, int ncache = 0)	1427	int set_cachesize (DB *db, U32 gbytes, U32 bytes, int ncache = 0)
		1428	CODE:
		1429	RETVAL = db->set_cachesize (db, gbytes, bytes, ncache);
		1430	OUTPUT:
		1431	RETVAL
957		1432
958	int set_flags (DB *env, U32 flags, int onoff)	1433	int set_flags (DB *db, U32 flags);
		1434	CODE:
		1435	RETVAL = db->set_flags (db, flags);
		1436	OUTPUT:
		1437	RETVAL
959		1438
960	int set_encrypt (DB db, const char password, U32 flags)	1439	int set_encrypt (DB db, const char password, U32 flags)
		1440	CODE:
		1441	RETVAL = db->set_encrypt (db, password, flags);
		1442	OUTPUT:
		1443	RETVAL
961		1444
962	int set_lorder (DB *db, int lorder)	1445	int set_lorder (DB *db, int lorder)
		1446	CODE:
		1447	RETVAL = db->set_lorder (db, lorder);
		1448	OUTPUT:
		1449	RETVAL
963		1450
964		1451
965	int set_bt_minkey (DB *db, U32 minkey)	1452	int set_bt_minkey (DB *db, U32 minkey)
		1453	CODE:
		1454	RETVAL = db->set_bt_minkey (db, minkey);
		1455	OUTPUT:
		1456	RETVAL
966		1457
967	int set_re_delim(DB *db, int delim);	1458	int set_re_delim(DB *db, int delim);
		1459	CODE:
		1460	RETVAL = db->set_re_delim (db, delim);
		1461	OUTPUT:
		1462	RETVAL
968		1463
969	int set_re_pad (DB *db, int re_pad)	1464	int set_re_pad (DB *db, int re_pad)
		1465	CODE:
		1466	RETVAL = db->set_re_pad (db, re_pad);
		1467	OUTPUT:
		1468	RETVAL
970		1469
971	int set_re_source (DB db, char source)	1470	int set_re_source (DB db, char source)
		1471	CODE:
		1472	RETVAL = db->set_re_source (db, source);
		1473	OUTPUT:
		1474	RETVAL
972		1475
973	int set_re_len (DB *db, U32 re_len)	1476	int set_re_len (DB *db, U32 re_len)
		1477	CODE:
		1478	RETVAL = db->set_re_len (db, re_len);
		1479	OUTPUT:
		1480	RETVAL
974		1481
975	int set_h_ffactor (DB *db, U32 h_ffactor)	1482	int set_h_ffactor (DB *db, U32 h_ffactor)
		1483	CODE:
		1484	RETVAL = db->set_h_ffactor (db, h_ffactor);
		1485	OUTPUT:
		1486	RETVAL
976		1487
977	int set_h_nelem (DB *db, U32 h_nelem)	1488	int set_h_nelem (DB *db, U32 h_nelem)
		1489	CODE:
		1490	RETVAL = db->set_h_nelem (db, h_nelem);
		1491	OUTPUT:
		1492	RETVAL
978		1493
979	int set_q_extentsize (DB *db, U32 extentsize)	1494	int set_q_extentsize (DB *db, U32 extentsize)
		1495	CODE:
		1496	RETVAL = db->set_q_extentsize (db, extentsize);
		1497	OUTPUT:
		1498	RETVAL
980		1499
		1500	DBC *
		1501	cursor (DB db, DB_TXN_ornull txn = 0, U32 flags = 0)
		1502	CODE:
		1503	errno = db->cursor (db, txn, &RETVAL, flags);
		1504	if (errno)
		1505	croak ("DB->cursor: %s", db_strerror (errno));
		1506	OUTPUT:
		1507	RETVAL
981		1508
		1509
		1510	MODULE = BDB PACKAGE = BDB::Txn
		1511
		1512	void
		1513	DESTROY (DB_TXN_ornull *txn)
		1514	CODE:
		1515	if (txn)
		1516	txn->abort (txn);
		1517
		1518	int set_timeout (DB_TXN *txn, NV timeout, U32 flags)
		1519	CODE:
		1520	RETVAL = txn->set_timeout (txn, timeout * 1000000, flags);
		1521	OUTPUT:
		1522	RETVAL
		1523
		1524
		1525	MODULE = BDB PACKAGE = BDB::Cursor
		1526
		1527	void
		1528	DESTROY (DBC_ornull *dbc)
		1529	CODE:
		1530	if (dbc)
		1531	dbc->c_close (dbc);
		1532

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.6 by root, Tue Feb 6 01:09:04 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.6 by root, Tue Feb 6 01:09:04 2007 UTC