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

Comparing BDB/BDB.xs (file contents):
Revision 1.27 by root, Mon Dec 17 06:31:43 2007 UTC vs.
Revision 1.35 by root, Sun Mar 30 07:12:12 2008 UTC

…		…
40	typedef DB_TXN DB_TXN_ornull;	40	typedef DB_TXN DB_TXN_ornull;
41	typedef DBC DBC_ornull;	41	typedef DBC DBC_ornull;
42	typedef DB DB_ornull;	42	typedef DB DB_ornull;
43	typedef DB_SEQUENCE DB_SEQUENCE_ornull;	43	typedef DB_SEQUENCE DB_SEQUENCE_ornull;
44		44
		45	typedef DB_ENV DB_ENV_ornuked;
		46	typedef DB_TXN DB_TXN_ornuked;
		47	typedef DBC DBC_ornuked;
		48	typedef DB DB_ornuked;
		49	typedef DB_SEQUENCE DB_SEQUENCE_ornuked;
		50
45	typedef SV SV8; /* byte-sv, used for argument-checking */	51	typedef SV SV8; /* byte-sv, used for argument-checking */
46	typedef char *octetstring;	52	typedef char *bdb_filename;
47		53
48	static SV *prepare_cb;	54	static SV *prepare_cb;
49		55
50	#if DB_VERSION_MINOR >= 6	56	#if DB_VERSION_MINOR >= 6
51	# define c_close close	57	# define c_close close
…		…
54	# define c_dup dup	60	# define c_dup dup
55	# define c_get get	61	# define c_get get
56	# define c_pget pget	62	# define c_pget pget
57	# define c_put put	63	# define c_put put
58	#endif	64	#endif
		65
		66	static char *
		67	get_bdb_filename (SV *sv)
		68	{
		69	return !SvOK (sv)
		70	? 0
		71	:
		72	#if _WIN32
		73	SvPVutf8_nolen (sv)
		74	#else
		75	SvPVbyte_nolen (sv)
		76	#endif
		77	;
		78	}
59		79
60	static void	80	static void
61	debug_errcall (const DB_ENV dbenv, const char errpfx, const char *msg)	81	debug_errcall (const DB_ENV dbenv, const char errpfx, const char *msg)
62	{	82	{
63	printf ("err[%s]\n", msg);	83	printf ("err[%s]\n", msg);
…		…
109	REQ_TXN_COMMIT, REQ_TXN_ABORT, REQ_TXN_FINISH,	129	REQ_TXN_COMMIT, REQ_TXN_ABORT, REQ_TXN_FINISH,
110	REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL,	130	REQ_C_CLOSE, REQ_C_COUNT, REQ_C_PUT, REQ_C_GET, REQ_C_PGET, REQ_C_DEL,
111	REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE,	131	REQ_SEQ_OPEN, REQ_SEQ_CLOSE, REQ_SEQ_GET, REQ_SEQ_REMOVE,
112	};	132	};
113		133
114	typedef struct aio_cb	134	typedef struct bdb_cb
115	{	135	{
116	struct aio_cb *volatile next;	136	struct bdb_cb *volatile next;
117	SV *callback;	137	SV *callback;
118	int type, pri, result;	138	int type, pri, result;
119		139
120	DB_ENV *env;	140	DB_ENV *env;
121	DB *db;	141	DB *db;
…		…
130		150
131	DBT dbt1, dbt2, dbt3;	151	DBT dbt1, dbt2, dbt3;
132	DB_KEY_RANGE key_range;	152	DB_KEY_RANGE key_range;
133	DB_SEQUENCE *seq;	153	DB_SEQUENCE *seq;
134	db_seq_t seq_t;	154	db_seq_t seq_t;
135	} aio_cb;	155	} bdb_cb;
136		156
137	typedef aio_cb *aio_req;	157	typedef bdb_cb *bdb_req;
138		158
139	enum {	159	enum {
140	PRI_MIN = -4,	160	PRI_MIN = -4,
141	PRI_MAX = 4,	161	PRI_MAX = 4,
142		162
…		…
169	struct worker prev, next;	189	struct worker prev, next;
170		190
171	thread_t tid;	191	thread_t tid;
172		192
173	/* locked by reslock, reqlock or wrklock */	193	/* locked by reslock, reqlock or wrklock */
174	aio_req req; /* currently processed request */	194	bdb_req req; /* currently processed request */
175	void *dbuf;	195	void *dbuf;
176	DIR *dirp;	196	DIR *dirp;
177	} worker;	197	} worker;
178		198
179	static worker wrk_first = { &wrk_first, &wrk_first, 0 };	199	static worker wrk_first = { &wrk_first, &wrk_first, 0 };
…		…
199	static mutex_t reqlock = X_MUTEX_INIT;	219	static mutex_t reqlock = X_MUTEX_INIT;
200	static cond_t reqwait = X_COND_INIT;	220	static cond_t reqwait = X_COND_INIT;
201		221
202	#if WORDACCESS_UNSAFE	222	#if WORDACCESS_UNSAFE
203		223
204	static unsigned int get_nready ()	224	static unsigned int get_nready (void)
205	{	225	{
206	unsigned int retval;	226	unsigned int retval;
207		227
208	X_LOCK (reqlock);	228	X_LOCK (reqlock);
209	retval = nready;	229	retval = nready;
210	X_UNLOCK (reqlock);	230	X_UNLOCK (reqlock);
211		231
212	return retval;	232	return retval;
213	}	233	}
214		234
215	static unsigned int get_npending ()	235	static unsigned int get_npending (void)
216	{	236	{
217	unsigned int retval;	237	unsigned int retval;
218		238
219	X_LOCK (reslock);	239	X_LOCK (reslock);
220	retval = npending;	240	retval = npending;
221	X_UNLOCK (reslock);	241	X_UNLOCK (reslock);
222		242
223	return retval;	243	return retval;
224	}	244	}
225		245
226	static unsigned int get_nthreads ()	246	static unsigned int get_nthreads (void)
227	{	247	{
228	unsigned int retval;	248	unsigned int retval;
229		249
230	X_LOCK (wrklock);	250	X_LOCK (wrklock);
231	retval = started;	251	retval = started;
…		…
246	* a somewhat faster data structure might be nice, but	266	* a somewhat faster data structure might be nice, but
247	* with 8 priorities this actually needs <20 insns	267	* with 8 priorities this actually needs <20 insns
248	* per shift, the most expensive operation.	268	* per shift, the most expensive operation.
249	*/	269	*/
250	typedef struct {	270	typedef struct {
251	aio_req qs[NUM_PRI], qe[NUM_PRI]; /* qstart, qend */	271	bdb_req qs[NUM_PRI], qe[NUM_PRI]; /* qstart, qend */
252	int size;	272	int size;
253	} reqq;	273	} reqq;
254		274
255	static reqq req_queue;	275	static reqq req_queue;
256	static reqq res_queue;	276	static reqq res_queue;
257		277
258	int reqq_push (reqq *q, aio_req req)	278	int reqq_push (reqq *q, bdb_req req)
259	{	279	{
260	int pri = req->pri;	280	int pri = req->pri;
261	req->next = 0;	281	req->next = 0;
262		282
263	if (q->qe[pri])	283	if (q->qe[pri])
…		…
269	q->qe[pri] = q->qs[pri] = req;	289	q->qe[pri] = q->qs[pri] = req;
270		290
271	return q->size++;	291	return q->size++;
272	}	292	}
273		293
274	aio_req reqq_shift (reqq *q)	294	bdb_req reqq_shift (reqq *q)
275	{	295	{
276	int pri;	296	int pri;
277		297
278	if (!q->size)	298	if (!q->size)
279	return 0;	299	return 0;
280		300
281	--q->size;	301	--q->size;
282		302
283	for (pri = NUM_PRI; pri--; )	303	for (pri = NUM_PRI; pri--; )
284	{	304	{
285	aio_req req = q->qs[pri];	305	bdb_req req = q->qs[pri];
286		306
287	if (req)	307	if (req)
288	{	308	{
289	if (!(q->qs[pri] = req->next))	309	if (!(q->qs[pri] = req->next))
290	q->qe[pri] = 0;	310	q->qe[pri] = 0;
…		…
294	}	314	}
295		315
296	abort ();	316	abort ();
297	}	317	}
298		318
299	static int poll_cb ();	319	static int poll_cb (void);
300	static void req_free (aio_req req);	320	static void req_free (bdb_req req);
301	static void req_cancel (aio_req req);	321	static void req_cancel (bdb_req req);
302		322
303	static int req_invoke (aio_req req)	323	static int req_invoke (bdb_req req)
304	{	324	{
305	dSP;	325	dSP;
306		326
307	if (SvOK (req->callback))	327	if (SvOK (req->callback))
308	{	328	{
…		…
371	}	391	}
372		392
373	return !SvTRUE (ERRSV);	393	return !SvTRUE (ERRSV);
374	}	394	}
375		395
376	static void req_free (aio_req req)	396	static void req_free (bdb_req req)
377	{	397	{
378	free (req->buf1);	398	free (req->buf1);
379	free (req->buf2);	399	free (req->buf2);
380	Safefree (req);	400	Safefree (req);
381	}	401	}
…		…
385	#else	405	#else
386	# define TO_SOCKET(x) (x)	406	# define TO_SOCKET(x) (x)
387	#endif	407	#endif
388		408
389	static void	409	static void
390	create_respipe ()	410	create_respipe (void)
391	{	411	{
392	#ifdef _WIN32	412	#ifdef _WIN32
393	int arg; /* argg */	413	int arg; /* argg */
394	#endif	414	#endif
395	int old_readfd = respipe [0];	415	int old_readfd = respipe [0];
…		…
449	free (wrk);	469	free (wrk);
450		470
451	X_UNLOCK (wrklock);	471	X_UNLOCK (wrklock);
452	}	472	}
453		473
454	static void maybe_start_thread ()	474	static void maybe_start_thread (void)
455	{	475	{
456	if (get_nthreads () >= wanted)	476	if (get_nthreads () >= wanted)
457	return;	477	return;
458		478
459	/* todo: maybe use idle here, but might be less exact */	479	/* todo: maybe use idle here, but might be less exact */
…		…
461	return;	481	return;
462		482
463	start_thread ();	483	start_thread ();
464	}	484	}
465		485
466	static void req_send (aio_req req)	486	static void req_send (bdb_req req)
467	{	487	{
468	SV *wait_callback = 0;	488	SV *wait_callback = 0;
469		489
470	// synthesize callback if none given	490	// synthesize callback if none given
471	if (!SvOK (req->callback))	491	if (!SvOK (req->callback))
…		…
505	}	525	}
506	}	526	}
507		527
508	static void end_thread (void)	528	static void end_thread (void)
509	{	529	{
510	aio_req req;	530	bdb_req req;
511		531
512	Newz (0, req, 1, aio_cb);	532	Newz (0, req, 1, bdb_cb);
513		533
514	req->type = REQ_QUIT;	534	req->type = REQ_QUIT;
515	req->pri = PRI_MAX + PRI_BIAS;	535	req->pri = PRI_MAX + PRI_BIAS;
516		536
517	X_LOCK (reqlock);	537	X_LOCK (reqlock);
…		…
544		564
545	while (started > wanted)	565	while (started > wanted)
546	end_thread ();	566	end_thread ();
547	}	567	}
548		568
549	static void poll_wait ()	569	static void poll_wait (void)
550	{	570	{
551	fd_set rfd;	571	fd_set rfd;
552		572
553	while (nreqs)	573	while (nreqs)
554	{	574	{
…		…
567		587
568	PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);	588	PerlSock_select (respipe [0] + 1, &rfd, 0, 0, 0);
569	}	589	}
570	}	590	}
571		591
572	static int poll_cb ()	592	static int poll_cb (void)
573	{	593	{
574	dSP;	594	dSP;
575	int count = 0;	595	int count = 0;
576	int maxreqs = max_poll_reqs;	596	int maxreqs = max_poll_reqs;
577	int do_croak = 0;	597	int do_croak = 0;
578	struct timeval tv_start, tv_now;	598	struct timeval tv_start, tv_now;
579	aio_req req;	599	bdb_req req;
580		600
581	if (max_poll_time)	601	if (max_poll_time)
582	gettimeofday (&tv_start, 0);	602	gettimeofday (&tv_start, 0);
583		603
584	for (;;)	604	for (;;)
…		…
645		665
646	/*****************************************************************************/	666	/*****************************************************************************/
647		667
648	X_THREAD_PROC (bdb_proc)	668	X_THREAD_PROC (bdb_proc)
649	{	669	{
650	aio_req req;	670	bdb_req req;
651	struct timespec ts;	671	struct timespec ts;
652	worker self = (worker )thr_arg;	672	worker self = (worker )thr_arg;
653		673
654	/* try to distribute timeouts somewhat evenly */	674	/* try to distribute timeouts somewhat evenly */
655	ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);	675	ts.tv_nsec = ((unsigned long)self & 1023UL) * (1000000000UL / 1024UL);
…		…
873	X_UNLOCK (wrklock);	893	X_UNLOCK (wrklock);
874	}	894	}
875		895
876	static void atfork_child (void)	896	static void atfork_child (void)
877	{	897	{
878	aio_req prv;	898	bdb_req prv;
879		899
880	while (prv = reqq_shift (&req_queue))	900	while (prv = reqq_shift (&req_queue))
881	req_free (prv);	901	req_free (prv);
882		902
883	while (prv = reqq_shift (&res_queue))	903	while (prv = reqq_shift (&res_queue))
…		…
904		924
905	atfork_parent ();	925	atfork_parent ();
906	}	926	}
907		927
908	#define dREQ(reqtype) \	928	#define dREQ(reqtype) \
909	aio_req req; \	929	bdb_req req; \
910	int req_pri = next_pri; \	930	int req_pri = next_pri; \
911	next_pri = DEFAULT_PRI + PRI_BIAS; \	931	next_pri = DEFAULT_PRI + PRI_BIAS; \
912	\	932	\
913	if (SvOK (callback) && !SvROK (callback)) \	933	if (SvOK (callback) && !SvROK (callback)) \
914	croak ("callback must be undef or of reference type"); \	934	croak ("callback must be undef or of reference type"); \
915	\	935	\
916	Newz (0, req, 1, aio_cb); \	936	Newz (0, req, 1, bdb_cb); \
917	if (!req) \	937	if (!req) \
918	croak ("out of memory during aio_req allocation"); \	938	croak ("out of memory during bdb_req allocation"); \
919	\	939	\
920	req->callback = newSVsv (callback); \	940	req->callback = newSVsv (callback); \
921	req->type = (reqtype); \	941	req->type = (reqtype); \
922	req->pri = req_pri	942	req->pri = req_pri
923		943
924	#define REQ_SEND \	944	#define REQ_SEND \
925	req_send (req)	945	req_send (req)
926		946
927	#define SvPTR(var, arg, type, class, nullok) \	947	#define SvPTR(var, arg, type, class, nullok) \
928	if (!SvOK (arg)) \	948	if (!SvOK (arg)) \
929	{ \	949	{ \
930	if (!nullok) \	950	if (nullok != 1) \
931	croak (# var " must be a " # class " object, not undef"); \	951	croak (# var " must be a " # class " object, not undef"); \
932	\	952	\
933	(var) = 0; \	953	(var) = 0; \
934	} \	954	} \
935	else if (sv_derived_from ((arg), # class)) \	955	else if (sv_derived_from ((arg), # class)) \
936	{ \	956	{ \
937	IV tmp = SvIV ((SV*) SvRV (arg)); \	957	IV tmp = SvIV ((SV*) SvRV (arg)); \
938	(var) = INT2PTR (type, tmp); \	958	(var) = INT2PTR (type, tmp); \
939	if (!var) \	959	if (!var && nullok != 2) \
940	croak (# var " is not a valid " # class " object anymore"); \	960	croak (# var " is not a valid " # class " object anymore"); \
941	} \	961	} \
942	else \	962	else \
943	croak (# var " is not of type " # class); \	963	croak (# var " is not of type " # class); \
944	\	964	\
…		…
946	static void	966	static void
947	ptr_nuke (SV *sv)	967	ptr_nuke (SV *sv)
948	{	968	{
949	assert (SvROK (sv));	969	assert (SvROK (sv));
950	sv_setiv (SvRV (sv), 0);	970	sv_setiv (SvRV (sv), 0);
		971	}
		972
		973	static int
		974	errno_get (pTHX_ SV sv, MAGIC mg)
		975	{
		976	if (*mg->mg_ptr == '!') // should always be the case
		977	if (-30999 <= errno && errno <= -30800)
		978	{
		979	sv_setnv (sv, (NV)errno);
		980	sv_setpv (sv, db_strerror (errno));
		981	SvNOK_on (sv); /* what a wonderful hack! */
		982	// ^^^ copied from perl sources
		983	return 0;
		984	}
		985
		986	return PL_vtbl_sv.svt_get (aTHX_ sv, mg);
		987	}
		988
		989	static MGVTBL vtbl_errno;
		990
		991	// this wonderful hack :( patches perl's $! variable to support our errno values
		992	static void
		993	patch_errno (void)
		994	{
		995	SV *sv;
		996	MAGIC *mg;
		997
		998	if (!(sv = get_sv ("!", 1)))
		999	return;
		1000
		1001	if (!(mg = mg_find (sv, PERL_MAGIC_sv)))
		1002	return;
		1003
		1004	if (mg->mg_virtual != &PL_vtbl_sv)
		1005	return;
		1006
		1007	vtbl_errno = PL_vtbl_sv;
		1008	vtbl_errno.svt_get = errno_get;
		1009	mg->mg_virtual = &vtbl_errno;
951	}	1010	}
952		1011
953	MODULE = BDB PACKAGE = BDB	1012	MODULE = BDB PACKAGE = BDB
954		1013
955	PROTOTYPES: ENABLE	1014	PROTOTYPES: ENABLE
…		…
1153	X_MUTEX_CHECK (reslock);	1212	X_MUTEX_CHECK (reslock);
1154	X_MUTEX_CHECK (reqlock);	1213	X_MUTEX_CHECK (reqlock);
1155		1214
1156	X_COND_CHECK (reqwait);	1215	X_COND_CHECK (reqwait);
1157	#endif	1216	#endif
		1217	patch_errno ();
1158	}	1218	}
1159		1219
1160	void	1220	void
1161	max_poll_reqs (int nreqs)	1221	max_poll_reqs (int nreqs)
1162	PROTOTYPE: $	1222	PROTOTYPE: $
…		…
1320	}	1380	}
1321	OUTPUT:	1381	OUTPUT:
1322	RETVAL	1382	RETVAL
1323		1383
1324	void	1384	void
1325	db_env_open (DB_ENV env, octetstring db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)	1385	db_env_open (DB_ENV env, bdb_filename db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)
1326	CODE:	1386	CODE:
1327	{	1387	{
1328	dREQ (REQ_ENV_OPEN);	1388	dREQ (REQ_ENV_OPEN);
1329
1330	env->set_thread_count (env, wanted + 2);
1331		1389
1332	req->env = env;	1390	req->env = env;
1333	req->uint1 = open_flags \| DB_THREAD;	1391	req->uint1 = open_flags \| DB_THREAD;
1334	req->int1 = mode;	1392	req->int1 = mode;
1335	req->buf1 = strdup_ornull (db_home);	1393	req->buf1 = strdup_ornull (db_home);
…		…
1403	}	1461	}
1404	OUTPUT:	1462	OUTPUT:
1405	RETVAL	1463	RETVAL
1406		1464
1407	void	1465	void
1408	db_open (DB db, DB_TXN_ornull txnid, octetstring file, octetstring database, int type, U32 flags, int mode, SV *callback = &PL_sv_undef)	1466	db_open (DB db, DB_TXN_ornull txnid, bdb_filename file, bdb_filename database, int type, U32 flags, int mode, SV *callback = &PL_sv_undef)
1409	CODE:	1467	CODE:
1410	{	1468	{
1411	dREQ (REQ_DB_OPEN);	1469	dREQ (REQ_DB_OPEN);
1412	req->db = db;	1470	req->db = db;
1413	req->txn = txnid;	1471	req->txn = txnid;
…		…
1453	req->uint1 = flags;	1511	req->uint1 = flags;
1454	REQ_SEND;	1512	REQ_SEND;
1455	}	1513	}
1456		1514
1457	void	1515	void
1458	db_upgrade (DB db, octetstring file, U32 flags = 0, SV callback = &PL_sv_undef)	1516	db_upgrade (DB db, bdb_filename file, U32 flags = 0, SV callback = &PL_sv_undef)
1459	CODE:	1517	CODE:
1460	{	1518	{
1461	dREQ (REQ_DB_SYNC);	1519	dREQ (REQ_DB_SYNC);
1462	req->db = db;	1520	req->db = db;
1463	req->buf1 = strdup (file);	1521	req->buf1 = strdup (file);
…		…
1492	}	1550	}
1493		1551
1494	void	1552	void
1495	db_get (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)	1553	db_get (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
1496	CODE:	1554	CODE:
1497	{
1498	if (SvREADONLY (data))	1555	if (SvREADONLY (data))
1499	croak ("can't modify read-only data scalar in db_get");	1556	croak ("can't modify read-only data scalar in db_get");
1500		1557	{
1501	dREQ (REQ_DB_GET);	1558	dREQ (REQ_DB_GET);
1502	req->db = db;	1559	req->db = db;
1503	req->txn = txn;	1560	req->txn = txn;
1504	req->uint1 = flags;	1561	req->uint1 = flags;
1505	sv_to_dbt (&req->dbt1, key);	1562	sv_to_dbt (&req->dbt1, key);
…		…
1509	}	1566	}
1510		1567
1511	void	1568	void
1512	db_pget (DB db, DB_TXN_ornull txn, SV key, SV pkey, SV data, U32 flags = 0, SV callback = &PL_sv_undef)	1569	db_pget (DB db, DB_TXN_ornull txn, SV key, SV pkey, SV data, U32 flags = 0, SV callback = &PL_sv_undef)
1513	CODE:	1570	CODE:
1514	{
1515	if (SvREADONLY (data))	1571	if (SvREADONLY (data))
1516	croak ("can't modify read-only data scalar in db_pget");	1572	croak ("can't modify read-only data scalar in db_pget");
1517		1573	{
1518	dREQ (REQ_DB_PGET);	1574	dREQ (REQ_DB_PGET);
1519	req->db = db;	1575	req->db = db;
1520	req->txn = txn;	1576	req->txn = txn;
1521	req->uint1 = flags;	1577	req->uint1 = flags;
1522	sv_to_dbt (&req->dbt1, key);	1578	sv_to_dbt (&req->dbt1, key);
…		…
1715		1771
1716		1772
1717	MODULE = BDB PACKAGE = BDB::Env	1773	MODULE = BDB PACKAGE = BDB::Env
1718		1774
1719	void	1775	void
1720	DESTROY (DB_ENV_ornull *env)	1776	DESTROY (DB_ENV_ornuked *env)
1721	CODE:	1777	CODE:
1722	if (env)	1778	if (env)
1723	env->close (env, 0);	1779	env->close (env, 0);
1724		1780
1725	int set_data_dir (DB_ENV env, const char dir)	1781	int set_data_dir (DB_ENV env, const char dir)
…		…
1872	RETVAL	1928	RETVAL
1873		1929
1874	MODULE = BDB PACKAGE = BDB::Db	1930	MODULE = BDB PACKAGE = BDB::Db
1875		1931
1876	void	1932	void
1877	DESTROY (DB_ornull *db)	1933	DESTROY (DB_ornuked *db)
1878	CODE:	1934	CODE:
1879	if (db)	1935	if (db)
1880	{	1936	{
1881	SV env = (SV )db->app_private;	1937	SV env = (SV )db->app_private;
1882	db->close (db, 0);	1938	db->close (db, 0);
…		…
1977		2033
1978		2034
1979	MODULE = BDB PACKAGE = BDB::Txn	2035	MODULE = BDB PACKAGE = BDB::Txn
1980		2036
1981	void	2037	void
1982	DESTROY (DB_TXN_ornull *txn)	2038	DESTROY (DB_TXN_ornuked *txn)
1983	CODE:	2039	CODE:
1984	if (txn)	2040	if (txn)
1985	txn->abort (txn);	2041	txn->abort (txn);
1986		2042
1987	int set_timeout (DB_TXN *txn, NV timeout, U32 flags = DB_SET_TXN_TIMEOUT)	2043	int set_timeout (DB_TXN *txn, NV timeout, U32 flags = DB_SET_TXN_TIMEOUT)
…		…
1998		2054
1999		2055
2000	MODULE = BDB PACKAGE = BDB::Cursor	2056	MODULE = BDB PACKAGE = BDB::Cursor
2001		2057
2002	void	2058	void
2003	DESTROY (DBC_ornull *dbc)	2059	DESTROY (DBC_ornuked *dbc)
2004	CODE:	2060	CODE:
2005	if (dbc)	2061	if (dbc)
2006	dbc->c_close (dbc);	2062	dbc->c_close (dbc);
2007		2063
2008	#if DB_VERSION_MINOR >= 6	2064	#if DB_VERSION_MINOR >= 6
…		…
2014	#endif	2070	#endif
2015		2071
2016	MODULE = BDB PACKAGE = BDB::Sequence	2072	MODULE = BDB PACKAGE = BDB::Sequence
2017		2073
2018	void	2074	void
2019	DESTROY (DB_SEQUENCE_ornull *seq)	2075	DESTROY (DB_SEQUENCE_ornuked *seq)
2020	CODE:	2076	CODE:
2021	if (seq)	2077	if (seq)
2022	seq->close (seq, 0);	2078	seq->close (seq, 0);
2023		2079
2024	int initial_value (DB_SEQUENCE *seq, db_seq_t value)	2080	int initial_value (DB_SEQUENCE *seq, db_seq_t value)
…		…
2043	CODE:	2099	CODE:
2044	RETVAL = seq->set_range (seq, min, max);	2100	RETVAL = seq->set_range (seq, min, max);
2045	OUTPUT:	2101	OUTPUT:
2046	RETVAL	2102	RETVAL
2047		2103
		2104

Diff Legend

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

Comparing BDB/BDB.xs (file contents): Revision 1.27 by root, Mon Dec 17 06:31:43 2007 UTC vs. Revision 1.35 by root, Sun Mar 30 07:12:12 2008 UTC

Diff Legend

Comparing BDB/BDB.xs (file contents):
Revision 1.27 by root, Mon Dec 17 06:31:43 2007 UTC vs.
Revision 1.35 by root, Sun Mar 30 07:12:12 2008 UTC