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

Comparing BDB/BDB.xs (file contents):
Revision 1.7 by root, Thu Feb 8 22:14:01 2007 UTC vs.
Revision 1.8 by root, Sun Feb 11 22:07:23 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;	45	typedef DB_ENV DB_ENV_ornull;
46	typedef DB_TXN DB_TXN_ornull;	46	typedef DB_TXN DB_TXN_ornull;
47	typedef DBC DBC_ornull;	47	typedef DBC DBC_ornull;
48	typedef DB DB_ornull;	48	typedef DB DB_ornull;
		49	typedef DB_SEQUENCE DB_SEQUENCE_ornull;
49		50
50	typedef SV SV8; /* byte-sv, used for argument-checking */	51	typedef SV SV8; /* byte-sv, used for argument-checking */
51	typedef char *octetstring;	52	typedef char *octetstring;
52		53
53	static SV *prepare_cb;	54	static SV *prepare_cb;
…		…
83	free (dbt->data);	84	free (dbt->data);
84	}	85	}
85		86
86	enum {	87	enum {
87	REQ_QUIT,	88	REQ_QUIT,
88	REQ_ENV_OPEN, REQ_ENV_CLOSE,	89	REQ_ENV_OPEN, REQ_ENV_CLOSE, REQ_ENV_TXN_CHECKPOINT, REQ_ENV_LOCK_DETECT,
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_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,
90	REQ_TXN_COMMIT, REQ_TXN_ABORT,	93	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,	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,
92	};	96	};
93		97
94	typedef struct aio_cb	98	typedef struct aio_cb
95	{	99	{
96	struct aio_cb *volatile next;	100	struct aio_cb *volatile next;
…		…
107	U32 uint1, uint2;	111	U32 uint1, uint2;
108	char buf1, buf2;	112	char buf1, buf2;
109	SV sv1, sv2, *sv3;	113	SV sv1, sv2, *sv3;
110		114
111	DBT dbt1, dbt2, dbt3;	115	DBT dbt1, dbt2, dbt3;
		116	DB_KEY_RANGE key_range;
		117	DB_SEQUENCE *seq;
		118	db_seq_t seq_t;
112	} aio_cb;	119	} aio_cb;
113		120
114	typedef aio_cb *aio_req;	121	typedef aio_cb *aio_req;
115		122
116	enum {	123	enum {
…		…
293	if (SvOK (req->callback))	300	if (SvOK (req->callback))
294	{	301	{
295	ENTER;	302	ENTER;
296	SAVETMPS;	303	SAVETMPS;
297	PUSHMARK (SP);	304	PUSHMARK (SP);
298	EXTEND (SP, 1);
299		305
300	switch (req->type)	306	switch (req->type)
301	{	307	{
302	case REQ_DB_CLOSE:	308	case REQ_DB_CLOSE:
303	SvREFCNT_dec (req->sv1);	309	SvREFCNT_dec (req->sv1);
…		…
311	case REQ_C_GET:	317	case REQ_C_GET:
312	case REQ_C_PGET:	318	case REQ_C_PGET:
313	dbt_to_sv (req->sv1, &req->dbt1);	319	dbt_to_sv (req->sv1, &req->dbt1);
314	dbt_to_sv (req->sv2, &req->dbt2);	320	dbt_to_sv (req->sv2, &req->dbt2);
315	dbt_to_sv (req->sv3, &req->dbt3);	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);
316	break;	347	break;
317	}	348	}
318		349
319	errno = req->result;	350	errno = req->result;
320		351
…		…
640		671
641	case REQ_ENV_CLOSE:	672	case REQ_ENV_CLOSE:
642	req->result = req->env->close (req->env, req->uint1);	673	req->result = req->env->close (req->env, req->uint1);
643	break;	674	break;
644		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
645	case REQ_DB_OPEN:	692	case REQ_DB_OPEN:
646	req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);	693	req->result = req->db->open (req->db, req->txn, req->buf1, req->buf2, req->int1, req->uint1, req->int2);
647	break;	694	break;
648		695
649	case REQ_DB_CLOSE:	696	case REQ_DB_CLOSE:
…		…
670	req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);	717	req->result = req->db->pget (req->db, req->txn, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
671	break;	718	break;
672		719
673	case REQ_DB_DEL:	720	case REQ_DB_DEL:
674	req->result = req->db->del (req->db, req->txn, &req->dbt1, req->uint1);	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);
675	break;	726	break;
676		727
677	case REQ_TXN_COMMIT:	728	case REQ_TXN_COMMIT:
678	req->result = req->txn->commit (req->txn, req->uint1);	729	req->result = req->txn->commit (req->txn, req->uint1);
679	break;	730	break;
…		…
706	req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);	757	req->result = req->dbc->c_pget (req->dbc, &req->dbt1, &req->dbt2, &req->dbt3, req->uint1);
707	break;	758	break;
708		759
709	case REQ_C_DEL:	760	case REQ_C_DEL:
710	req->result = req->dbc->c_del (req->dbc, req->uint1);	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);
711	break;	778	break;
712		779
713	default:	780	default:
714	req->result = ENOSYS;	781	req->result = ENOSYS;
715	break;	782	break;
…		…
952	const_iv (AFTER)	1019	const_iv (AFTER)
953	const_iv (CURRENT)	1020	const_iv (CURRENT)
954	const_iv (KEYFIRST)	1021	const_iv (KEYFIRST)
955	const_iv (KEYLAST)	1022	const_iv (KEYLAST)
956	const_iv (NODUPDATA)	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)
957	};	1040	};
958		1041
959	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; )
960	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1043	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
961		1044
…		…
1100	PROTOTYPE: &	1183	PROTOTYPE: &
1101	CODE:	1184	CODE:
1102	SvREFCNT_dec (prepare_cb);	1185	SvREFCNT_dec (prepare_cb);
1103	prepare_cb = newSVsv (cb);	1186	prepare_cb = newSVsv (cb);
1104		1187
		1188
1105	DB_ENV *	1189	DB_ENV *
1106	db_env_create (U32 env_flags = 0)	1190	db_env_create (U32 env_flags = 0)
1107	CODE:	1191	CODE:
1108	{	1192	{
1109	errno = db_env_create (&RETVAL, env_flags);	1193	errno = db_env_create (&RETVAL, env_flags);
…		…
1115		1199
1116	void	1200	void
1117	db_env_open (DB_ENV env, octetstring db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)	1201	db_env_open (DB_ENV env, octetstring db_home, U32 open_flags, int mode, SV callback = &PL_sv_undef)
1118	CODE:	1202	CODE:
1119	{	1203	{
		1204	env->set_thread_count (env, get_nthreads ());
		1205
1120	dREQ (REQ_ENV_OPEN);	1206	dREQ (REQ_ENV_OPEN);
1121	req->env = env;	1207	req->env = env;
1122	req->uint1 = open_flags \| DB_THREAD;	1208	req->uint1 = open_flags \| DB_THREAD;
1123	req->int1 = mode;	1209	req->int1 = mode;
1124	req->buf1 = strdup_ornull (db_home);	1210	req->buf1 = strdup_ornull (db_home);
…		…
1133	req->env = env;	1219	req->env = env;
1134	req->uint1 = flags;	1220	req->uint1 = flags;
1135	REQ_SEND;	1221	REQ_SEND;
1136	ptr_nuke (ST (0));	1222	ptr_nuke (ST (0));
1137	}	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
1138		1267
1139	DB *	1268	DB *
1140	db_create (DB_ENV *env = 0, U32 flags = 0)	1269	db_create (DB_ENV *env = 0, U32 flags = 0)
1141	CODE:	1270	CODE:
1142	{	1271	{
…		…
1199	req->uint1 = flags;	1328	req->uint1 = flags;
1200	REQ_SEND;	1329	REQ_SEND;
1201	}	1330	}
1202		1331
1203	void	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
1204	db_put (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)	1346	db_put (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = &PL_sv_undef)
1205	CODE:	1347	CODE:
1206	{	1348	{
1207	dREQ (REQ_DB_PUT);	1349	dREQ (REQ_DB_PUT);
1208	req->db = db;	1350	req->db = db;
…		…
1369	req->uint1 = flags;	1511	req->uint1 = flags;
1370	REQ_SEND;	1512	REQ_SEND;
1371	}	1513	}
1372		1514
1373		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;
		1560	REQ_SEND;
		1561	}
		1562
		1563
1374	MODULE = BDB PACKAGE = BDB::Env	1564	MODULE = BDB PACKAGE = BDB::Env
1375		1565
1376	void	1566	void
1377	DESTROY (DB_ENV_ornull *env)	1567	DESTROY (DB_ENV_ornull *env)
1378	CODE:	1568	CODE:
1379	if (env)	1569	if (env)
1380	env->close (env, 0);	1570	env->close (env, 0);
1381		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
1382	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)
1383	CODE:	1597	CODE:
1384	RETVAL = env->set_cachesize (env, gbytes, bytes, ncache);	1598	RETVAL = env->set_cachesize (env, gbytes, bytes, ncache);
1385	OUTPUT:	1599	OUTPUT:
1386	RETVAL	1600	RETVAL
…		…
1398	RETVAL	1612	RETVAL
1399		1613
1400	int set_timeout (DB_ENV *env, NV timeout, U32 flags)	1614	int set_timeout (DB_ENV *env, NV timeout, U32 flags)
1401	CODE:	1615	CODE:
1402	RETVAL = env->set_timeout (env, timeout * 1000000, flags);	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)
		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);
1403	OUTPUT:	1671	OUTPUT:
1404	RETVAL	1672	RETVAL
1405		1673
1406	DB_TXN *	1674	DB_TXN *
1407	txn_begin (DB_ENV env, DB_TXN_ornull parent = 0, U32 flags = 0)	1675	txn_begin (DB_ENV env, DB_TXN_ornull parent = 0, U32 flags = 0)
…		…
1446	CODE:	1714	CODE:
1447	RETVAL = db->set_lorder (db, lorder);	1715	RETVAL = db->set_lorder (db, lorder);
1448	OUTPUT:	1716	OUTPUT:
1449	RETVAL	1717	RETVAL
1450		1718
1451
1452	int set_bt_minkey (DB *db, U32 minkey)	1719	int set_bt_minkey (DB *db, U32 minkey)
1453	CODE:	1720	CODE:
1454	RETVAL = db->set_bt_minkey (db, minkey);	1721	RETVAL = db->set_bt_minkey (db, minkey);
1455	OUTPUT:	1722	OUTPUT:
1456	RETVAL	1723	RETVAL
…		…
1504	if (errno)	1771	if (errno)
1505	croak ("DB->cursor: %s", db_strerror (errno));	1772	croak ("DB->cursor: %s", db_strerror (errno));
1506	OUTPUT:	1773	OUTPUT:
1507	RETVAL	1774	RETVAL
1508		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
1509		1787
1510	MODULE = BDB PACKAGE = BDB::Txn	1788	MODULE = BDB PACKAGE = BDB::Txn
1511		1789
1512	void	1790	void
1513	DESTROY (DB_TXN_ornull *txn)	1791	DESTROY (DB_TXN_ornull *txn)
…		…
1528	DESTROY (DBC_ornull *dbc)	1806	DESTROY (DBC_ornull *dbc)
1529	CODE:	1807	CODE:
1530	if (dbc)	1808	if (dbc)
1531	dbc->c_close (dbc);	1809	dbc->c_close (dbc);
1532		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.7 by root, Thu Feb 8 22:14:01 2007 UTC vs. Revision 1.8 by root, Sun Feb 11 22:07:23 2007 UTC

Diff Legend

Comparing BDB/BDB.xs (file contents):
Revision 1.7 by root, Thu Feb 8 22:14:01 2007 UTC vs.
Revision 1.8 by root, Sun Feb 11 22:07:23 2007 UTC