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

Comparing BDB/BDB.xs (file contents):
Revision 1.5 by root, Mon Feb 5 23:46:15 2007 UTC vs.
Revision 1.10 by root, Mon Mar 5 19:47:01 2007 UTC

…		…
24	#include <limits.h>	24	#include <limits.h>
25	#include <unistd.h>	25	#include <unistd.h>
26	#include <fcntl.h>	26	#include <fcntl.h>
27		27
28	#include <db.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
29		33
30	/* number of seconds after which idle threads exit */	34	/* number of seconds after which idle threads exit */
31	#define IDLE_TIMEOUT 10	35	#define IDLE_TIMEOUT 10
32		36
33	/* wether word reads are potentially non-atomic.	37	/* wether word reads are potentially non-atomic.
…		…
40	# else	44	# else
41	# define WORDACCESS_UNSAFE 1	45	# define WORDACCESS_UNSAFE 1
42	# endif	46	# endif
43	#endif	47	#endif
44		48
45	typedef DB_ENV DB_ENV_ornull;	49	typedef DB_ENV DB_ENV_ornull;
46	typedef DB_TXN DB_TXN_ornull;	50	typedef DB_TXN DB_TXN_ornull;
47	typedef DBC DBC_ornull;	51	typedef DBC DBC_ornull;
48	typedef DB DB_ornull;	52	typedef DB DB_ornull;
		53	typedef DB_SEQUENCE DB_SEQUENCE_ornull;
49		54
50	typedef SV SV8; /* byte-sv, used for argument-checking */	55	typedef SV SV8; /* byte-sv, used for argument-checking */
51	typedef char *octetstring;	56	typedef char *octetstring;
52		57
53	static SV *prepare_cb;	58	static SV *prepare_cb;
…		…
56	strdup_ornull (const char *s)	61	strdup_ornull (const char *s)
57	{	62	{
58	return s ? strdup (s) : 0;	63	return s ? strdup (s) : 0;
59	}	64	}
60		65
61	inline void	66	static inline void
62	sv_to_dbt (DBT dbt, SV sv)	67	sv_to_dbt (DBT dbt, SV sv)
63	{	68	{
64	STRLEN len;	69	STRLEN len;
65	char *data = SvPVbyte (sv, len);	70	char *data = SvPVbyte (sv, len);
66		71
67	dbt->data = malloc (len);	72	dbt->data = malloc (len);
68	memcpy (dbt->data, data, len);	73	memcpy (dbt->data, data, len);
69	dbt->size = len;	74	dbt->size = len;
		75	dbt->flags = DB_DBT_REALLOC;
70	}	76	}
71		77
72	inline void	78	static inline void
73	dbt_to_sv (SV sv, DBT dbt)	79	dbt_to_sv (SV sv, DBT dbt)
74	{	80	{
		81	if (sv)
		82	{
75	SvREADONLY_off (sv);	83	SvREADONLY_off (sv);
76	sv_setpvn_mg (sv, dbt->data, dbt->size);	84	sv_setpvn_mg (sv, dbt->data, dbt->size);
		85	SvREFCNT_dec (sv);
		86	}
77		87
78	free (dbt->data);	88	free (dbt->data);
79	}	89	}
80		90
81	enum {	91	enum {
82	REQ_QUIT,	92	REQ_QUIT,
83	REQ_ENV_OPEN, REQ_ENV_CLOSE,	93	REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT,
		94	REQ_ENV_MEMP_SYNC, REQ_ENV_MEMP_TRICKLE,
84	REQ_DB_OPEN, REQ_DB_CLOSE, REQ_DB_COMPACT, REQ_DB_SYNC, REQ_DB_PUT, REQ_DB_GET, REQ_DB_PGET,	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,
85	REQ_TXN_COMMIT, REQ_TXN_ABORT,	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,
86	};	100	};
87		101
88	typedef struct aio_cb	102	typedef struct aio_cb
89	{	103	{
90	struct aio_cb *volatile next;	104	struct aio_cb *volatile next;
…		…
92	int type, pri, result;	106	int type, pri, result;
93		107
94	DB_ENV *env;	108	DB_ENV *env;
95	DB *db;	109	DB *db;
96	DB_TXN *txn;	110	DB_TXN *txn;
97	DBC *cursor;	111	DBC *dbc;
		112
		113	UV uv1;
98	int int1, int2;	114	int int1, int2;
99	U32 uint1, uint2;	115	U32 uint1, uint2;
100	char buf1, buf2;	116	char buf1, buf2;
101	SV sv1, sv2;	117	SV sv1, sv2, *sv3;
102		118
103	DBT dbt1, dbt2, dbt3;	119	DBT dbt1, dbt2, dbt3;
		120	DB_KEY_RANGE key_range;
		121	DB_SEQUENCE *seq;
		122	db_seq_t seq_t;
104	} aio_cb;	123	} aio_cb;
105		124
106	typedef aio_cb *aio_req;	125	typedef aio_cb *aio_req;
107		126
108	enum {	127	enum {
…		…
285	if (SvOK (req->callback))	304	if (SvOK (req->callback))
286	{	305	{
287	ENTER;	306	ENTER;
288	SAVETMPS;	307	SAVETMPS;
289	PUSHMARK (SP);	308	PUSHMARK (SP);
290	EXTEND (SP, 1);
291		309
292	switch (req->type)	310	switch (req->type)
293	{	311	{
		312	case REQ_DB_CLOSE:
		313	SvREFCNT_dec (req->sv1);
		314	break;
		315
294	case REQ_DB_GET:	316	case REQ_DB_GET:
295	case REQ_DB_PGET:	317	case REQ_DB_PGET:
296	dbt_to_sv (req->sv1, &req->dbt3);	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));
297	SvREFCNT_dec (req->sv1);	338	SvREFCNT_dec (req->sv1);
298	break;	339	}
		340	break;
299		341
300	case REQ_DB_CLOSE:	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
301	SvREFCNT_dec (req->sv1);	350	SvREFCNT_dec (req->sv1);
302	break;	351	break;
303	}	352	}
304		353
305	errno = req->result;	354	errno = req->result;
…		…
626		675
627	case REQ_ENV_CLOSE:	676	case REQ_ENV_CLOSE:
628	req->result = req->env->close (req->env, req->uint1);	677	req->result = req->env->close (req->env, req->uint1);
629	break;	678	break;
630		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
631	case REQ_DB_OPEN:	696	case REQ_DB_OPEN:
632	req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);	697	req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
633	break;	698	break;
634		699
635	case REQ_DB_CLOSE:	700	case REQ_DB_CLOSE:
…		…
654		719
655	case REQ_DB_PGET:	720	case REQ_DB_PGET:
656	req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);	721	req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
657	break;	722	break;
658		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
659	case REQ_TXN_COMMIT:	732	case REQ_TXN_COMMIT:
660	req->result = req->txn->commit (req->txn, req->uint1);	733	req->result = req->txn->commit (req->txn, req->uint1);
661	break;	734	break;
662		735
663	case REQ_TXN_ABORT:	736	case REQ_TXN_ABORT:
664	req->result = req->txn->abort (req->txn);	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);
665	break;	782	break;
666		783
667	default:	784	default:
668	req->result = ENOSYS;	785	req->result = ENOSYS;
669	break;	786	break;
…		…
762		879
763	#define SvPTR(var, arg, type, class, nullok) \	880	#define SvPTR(var, arg, type, class, nullok) \
764	if (!SvOK (arg)) \	881	if (!SvOK (arg)) \
765	{ \	882	{ \
766	if (!nullok) \	883	if (!nullok) \
767	Perl_croak (# var " must be a " # class " object, not undef"); \	884	croak (# var " must be a " # class " object, not undef"); \
768	\	885	\
769	(var) = 0; \	886	(var) = 0; \
770	} \	887	} \
771	else if (sv_derived_from ((arg), # class)) \	888	else if (sv_derived_from ((arg), # class)) \
772	{ \	889	{ \
773	IV tmp = SvIV ((SV*) SvRV (arg)); \	890	IV tmp = SvIV ((SV*) SvRV (arg)); \
774	(var) = INT2PTR (type, tmp); \	891	(var) = INT2PTR (type, tmp); \
775	if (!var) \	892	if (!var) \
776	Perl_croak (# var " is not a valid " # class " object anymore"); \	893	croak (# var " is not a valid " # class " object anymore"); \
777	} \	894	} \
778	else \	895	else \
779	Perl_croak (# var " is not of type " # class); \	896	croak (# var " is not of type " # class); \
780	\	897	\
781		898
782	static void	899	static void
783	ptr_nuke (SV *sv)	900	ptr_nuke (SV *sv)
784	{	901	{
…		…
859	const_iv (REVSPLITOFF)	976	const_iv (REVSPLITOFF)
860	const_iv (INORDER)	977	const_iv (INORDER)
861	const_iv (CONSUME)	978	const_iv (CONSUME)
862	const_iv (CONSUME_WAIT)	979	const_iv (CONSUME_WAIT)
863	const_iv (GET_BOTH)	980	const_iv (GET_BOTH)
		981	const_iv (GET_BOTH_RANGE)
864	//const_iv (SET_RECNO)	982	//const_iv (SET_RECNO)
865	//const_iv (MULTIPLE)	983	//const_iv (MULTIPLE)
866	const_iv (SNAPSHOT)	984	const_iv (SNAPSHOT)
867	const_iv (JOIN_ITEM)	985	const_iv (JOIN_ITEM)
868	const_iv (RMW)	986	const_iv (RMW)
…		…
873	const_iv (LOCK_NOTGRANTED)	991	const_iv (LOCK_NOTGRANTED)
874	const_iv (RUNRECOVERY)	992	const_iv (RUNRECOVERY)
875	const_iv (OLD_VERSION)	993	const_iv (OLD_VERSION)
876	const_iv (REP_HANDLE_DEAD)	994	const_iv (REP_HANDLE_DEAD)
877	const_iv (REP_LOCKOUT)	995	const_iv (REP_LOCKOUT)
		996	const_iv (SECONDARY_BAD)
878		997
879	const_iv (FREE_SPACE)	998	const_iv (FREE_SPACE)
880	const_iv (FREELIST_ONLY)	999	const_iv (FREELIST_ONLY)
881		1000
882	const_iv (APPEND)	1001	const_iv (APPEND)
…		…
887	const_iv (TXN_SNAPSHOT)	1006	const_iv (TXN_SNAPSHOT)
888	const_iv (TXN_SYNC)	1007	const_iv (TXN_SYNC)
889		1008
890	const_iv (SET_LOCK_TIMEOUT)	1009	const_iv (SET_LOCK_TIMEOUT)
891	const_iv (SET_TXN_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)
892	};	1044	};
893		1045
894	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1046	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
895	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1047	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
896		1048
…		…
1035	PROTOTYPE: &	1187	PROTOTYPE: &
1036	CODE:	1188	CODE:
1037	SvREFCNT_dec (prepare_cb);	1189	SvREFCNT_dec (prepare_cb);
1038	prepare_cb = newSVsv (cb);	1190	prepare_cb = newSVsv (cb);
1039		1191
		1192
1040	DB_ENV *	1193	DB_ENV *
1041	db_env_create (U32 env_flags = 0)	1194	db_env_create (U32 env_flags = 0)
1042	CODE:	1195	CODE:
1043	{	1196	{
1044	errno = db_env_create (&RETVAL, env_flags);	1197	errno = db_env_create (&RETVAL, env_flags);
…		…
1050		1203
1051	void	1204	void
1052	db_env_open (DB_ENV env, octetstring db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)	1205	db_env_open (DB_ENV env, octetstring db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)
1053	CODE:	1206	CODE:
1054	{	1207	{
		1208	env->set_thread_count (env, get_nthreads ());
		1209
1055	dREQ (REQ_ENV_OPEN);	1210	dREQ (REQ_ENV_OPEN);
1056	req->env = env;	1211	req->env = env;
1057	req->uint1 = open_flags \| DB_THREAD;	1212	req->uint1 = open_flags \| DB_THREAD;
1058	req->int1 = mode;	1213	req->int1 = mode;
1059	req->buf1 = strdup_ornull (db_home);	1214	req->buf1 = strdup_ornull (db_home);
…		…
1069	req->uint1 = flags;	1224	req->uint1 = flags;
1070	REQ_SEND;	1225	REQ_SEND;
1071	ptr_nuke (ST (0));	1226	ptr_nuke (ST (0));
1072	}	1227	}
1073		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
1074	DB *	1272	DB *
1075	db_create (DB_ENV *env = 0, U32 flags = 0)	1273	db_create (DB_ENV *env = 0, U32 flags = 0)
1076	CODE:	1274	CODE:
1077	{	1275	{
1078	errno = db_create (&RETVAL, env, flags);	1276	errno = db_create (&RETVAL, env, flags);
1079	if (errno)	1277	if (errno)
1080	croak ("db_env_create: %s", db_strerror (errno));	1278	croak ("db_create: %s", db_strerror (errno));
1081		1279
1082	if (RETVAL)	1280	if (RETVAL)
1083	RETVAL->app_private = (void *)newSVsv (ST (0));	1281	RETVAL->app_private = (void *)newSVsv (ST (0));
1084	}	1282	}
1085	OUTPUT:	1283	OUTPUT:
…		…
1134	req->uint1 = flags;	1332	req->uint1 = flags;
1135	REQ_SEND;	1333	REQ_SEND;
1136	}	1334	}
1137		1335
1138	void	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
1139	db_put (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)	1350	db_put (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
1140	CODE:	1351	CODE:
1141	{	1352	{
1142	dREQ (REQ_DB_PUT);	1353	dREQ (REQ_DB_PUT);
1143	req->db = db;	1354	req->db = db;
…		…
1153	CODE:	1364	CODE:
1154	{	1365	{
1155	dREQ (REQ_DB_GET);	1366	dREQ (REQ_DB_GET);
1156	req->db = db;	1367	req->db = db;
1157	req->txn = txn;	1368	req->txn = txn;
		1369	req->uint1 = flags;
1158	sv_to_dbt (&req->dbt1, key);	1370	sv_to_dbt (&req->dbt1, key);
1159	req->dbt3.flags = DB_DBT_MALLOC;	1371	req->dbt3.flags = DB_DBT_MALLOC;
1160	req->uint1 = flags;
1161	req->sv1 = SvREFCNT_inc (data);	1372	req->sv3 = SvREFCNT_inc (data); SvREADONLY_on (data);
1162	SvREADONLY_on (data);
1163	REQ_SEND;	1373	REQ_SEND;
1164	}	1374	}
1165		1375
1166	void	1376	void
1167	db_pget (DB db, DB_TXN_ornull txn, SV key, SV pkey, SV data, U32 flags = 0, SV callback = &PL_sv_undef)	1377	db_pget (DB db, DB_TXN_ornull txn, SV key, SV pkey, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
1168	CODE:	1378	CODE:
1169	{	1379	{
1170	dREQ (REQ_DB_PGET);	1380	dREQ (REQ_DB_PGET);
1171	req->db = db;	1381	req->db = db;
1172	req->txn = txn;	1382	req->txn = txn;
		1383	req->uint1 = flags;
1173	sv_to_dbt (&req->dbt1, key);	1384	sv_to_dbt (&req->dbt1, key);
1174	sv_to_dbt (&req->dbt2, pkey);	1385	sv_to_dbt (&req->dbt2, pkey);
1175	req->dbt3.flags = DB_DBT_MALLOC;	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;
1176	req->uint1 = flags;	1398	req->uint1 = flags;
1177	req->sv1 = SvREFCNT_inc (data);	1399	sv_to_dbt (&req->dbt1, key);
1178	SvREADONLY_on (data);
1179	REQ_SEND;	1400	REQ_SEND;
1180	}	1401	}
1181		1402
1182	void	1403	void
1183	db_txn_commit (DB_TXN txn, U32 flags = 0, SV callback = &PL_sv_undef)	1404	db_txn_commit (DB_TXN txn, U32 flags = 0, SV callback = &PL_sv_undef)
…		…
1198	req->txn = txn;	1419	req->txn = txn;
1199	REQ_SEND;	1420	REQ_SEND;
1200	ptr_nuke (ST (0));	1421	ptr_nuke (ST (0));
1201	}	1422	}
1202		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
1203		1567
1204	MODULE = BDB PACKAGE = BDB::Env	1568	MODULE = BDB PACKAGE = BDB::Env
1205		1569
1206	void	1570	void
1207	DESTROY (DB_ENV_ornull *env)	1571	DESTROY (DB_ENV_ornull *env)
1208	CODE:	1572	CODE:
1209	if (env)	1573	if (env)
1210	env->close (env, 0);	1574	env->close (env, 0);
1211		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
1212	int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0)	1600	int set_cachesize (DB_ENV *env, U32 gbytes, U32 bytes, int ncache = 0)
1213	CODE:	1601	CODE:
1214	RETVAL = env->set_cachesize (env, gbytes, bytes, ncache);	1602	RETVAL = env->set_cachesize (env, gbytes, bytes, ncache);
1215	OUTPUT:	1603	OUTPUT:
1216	RETVAL	1604	RETVAL
…		…
1228	RETVAL	1616	RETVAL
1229		1617
1230	int set_timeout (DB_ENV *env, NV timeout, U32 flags)	1618	int set_timeout (DB_ENV *env, NV timeout, U32 flags)
1231	CODE:	1619	CODE:
1232	RETVAL = env->set_timeout (env, timeout * 1000000, flags);	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);
1233	OUTPUT:	1675	OUTPUT:
1234	RETVAL	1676	RETVAL
1235		1677
1236	DB_TXN *	1678	DB_TXN *
1237	txn_begin (DB_ENV env, DB_TXN_ornull parent = 0, U32 flags = 0)	1679	txn_begin (DB_ENV env, DB_TXN_ornull parent = 0, U32 flags = 0)
1238	CODE:	1680	CODE:
1239	errno = env->txn_begin (env, parent, &RETVAL, flags);	1681	errno = env->txn_begin (env, parent, &RETVAL, flags);
1240	if (errno)	1682	if (errno)
1241	croak ("txn_begin: %s", db_strerror (errno));	1683	croak ("DB_ENV->txn_begin: %s", db_strerror (errno));
1242	OUTPUT:	1684	OUTPUT:
1243	RETVAL	1685	RETVAL
1244		1686
1245	MODULE = BDB PACKAGE = BDB::Db	1687	MODULE = BDB PACKAGE = BDB::Db
1246		1688
…		…
1276	CODE:	1718	CODE:
1277	RETVAL = db->set_lorder (db, lorder);	1719	RETVAL = db->set_lorder (db, lorder);
1278	OUTPUT:	1720	OUTPUT:
1279	RETVAL	1721	RETVAL
1280		1722
1281
1282	int set_bt_minkey (DB *db, U32 minkey)	1723	int set_bt_minkey (DB *db, U32 minkey)
1283	CODE:	1724	CODE:
1284	RETVAL = db->set_bt_minkey (db, minkey);	1725	RETVAL = db->set_bt_minkey (db, minkey);
1285	OUTPUT:	1726	OUTPUT:
1286	RETVAL	1727	RETVAL
…		…
1324	int set_q_extentsize (DB *db, U32 extentsize)	1765	int set_q_extentsize (DB *db, U32 extentsize)
1325	CODE:	1766	CODE:
1326	RETVAL = db->set_q_extentsize (db, extentsize);	1767	RETVAL = db->set_q_extentsize (db, extentsize);
1327	OUTPUT:	1768	OUTPUT:
1328	RETVAL	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
1329		1791
1330	MODULE = BDB PACKAGE = BDB::Txn	1792	MODULE = BDB PACKAGE = BDB::Txn
1331		1793
1332	void	1794	void
1333	DESTROY (DB_TXN_ornull *txn)	1795	DESTROY (DB_TXN_ornull *txn)
…		…
1340	RETVAL = txn->set_timeout (txn, timeout * 1000000, flags);	1802	RETVAL = txn->set_timeout (txn, timeout * 1000000, flags);
1341	OUTPUT:	1803	OUTPUT:
1342	RETVAL	1804	RETVAL
1343		1805
1344		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.5 by root, Mon Feb 5 23:46:15 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.5 by root, Mon Feb 5 23:46:15 2007 UTC vs.
Revision 1.10 by root, Mon Mar 5 19:47:01 2007 UTC