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

Comparing BDB/BDB.pm (file contents):
Revision 1.7 by root, Mon Mar 5 19:47:01 2007 UTC vs.
Revision 1.57 by root, Tue Jul 14 19:29:23 2009 UTC

…		…
4		4
5	=head1 SYNOPSIS	5	=head1 SYNOPSIS
6		6
7	use BDB;	7	use BDB;
8		8
		9	my $env = db_env_create;
		10
		11	mkdir "bdtest", 0700;
		12	db_env_open
		13	$env,
		14	"bdtest",
		15	BDB::INIT_LOCK \| BDB::INIT_LOG \| BDB::INIT_MPOOL
		16	\| BDB::INIT_TXN \| BDB::RECOVER \| BDB::USE_ENVIRON \| BDB::CREATE,
		17	0600;
		18
		19	$env->set_flags (BDB::AUTO_COMMIT \| BDB::TXN_NOSYNC, 1);
		20
		21	my $db = db_create $env;
		22	db_open $db, undef, "table", undef, BDB::BTREE, BDB::AUTO_COMMIT \| BDB::CREATE
		23	\| BDB::READ_UNCOMMITTED, 0600;
		24	db_put $db, undef, "key", "data", 0, sub {
		25	db_del $db, undef, "key";
		26	};
		27	db_sync $db;
		28
		29	# when you also use Coro, management is easy:
		30	use Coro::BDB;
		31
		32	# automatic event loop intergration with AnyEvent:
		33	use AnyEvent::BDB;
		34
		35	# automatic result processing with EV:
		36	my $WATCHER = EV::io BDB::poll_fileno, EV::READ, \&BDB::poll_cb;
		37
		38	# with Glib:
		39	add_watch Glib::IO BDB::poll_fileno,
		40	in => sub { BDB::poll_cb; 1 };
		41
		42	# or simply flush manually
		43	BDB::flush;
		44
		45
9	=head1 DESCRIPTION	46	=head1 DESCRIPTION
10		47
11	See the eg/ directory in the distribution and the berkeleydb C	48	See the BerkeleyDB documentation (L<http://www.oracle.com/technology/documentation/berkeley-db/db/index.html>).
12	documentation. This is inadequate, but the only sources of documentation	49	The BDB API is very similar to the C API (the translation has been very faithful).
13	known for this module so far.
14		50
15	=head2 EXAMPLE	51	See also the example sections in the document below and possibly the eg/
		52	subdirectory of the BDB distribution. Last not least see the IO::AIO
		53	documentation, as that module uses almost the same asynchronous request
		54	model as this module.
		55
		56	I know this is woefully inadequate documentation. Send a patch!
		57
16		58
17	=head1 REQUEST ANATOMY AND LIFETIME	59	=head1 REQUEST ANATOMY AND LIFETIME
18		60
19	Every request method creates a request. which is a C data structure not	61	Every request method creates a request. which is a C data structure not
20	directly visible to Perl.	62	directly visible to Perl.
…		…
61		103
62	=cut	104	=cut
63		105
64	package BDB;	106	package BDB;
65		107
66	no warnings;	108	use common::sense;
67	use strict 'vars';
68		109
69	use base 'Exporter';	110	use base 'Exporter';
70		111
		112	our $VERSION;
		113
71	BEGIN {	114	BEGIN {
72	our $VERSION = '0.1';	115	$VERSION = '1.84';
73		116
74	our @BDB_REQ = qw(	117	our @BDB_REQ = qw(
75	db_env_open db_env_close db_env_txn_checkpoint db_env_lock_detect	118	db_env_open db_env_close db_env_txn_checkpoint db_env_lock_detect
76	db_env_memp_sync db_env_memp_trickle	119	db_env_memp_sync db_env_memp_trickle db_env_dbrename db_env_dbremove
77	db_open db_close db_compact db_sync db_put db_get db_pget db_del db_key_range	120	db_env_log_archive
		121	db_open db_close db_compact db_sync db_verify db_upgrade
		122	db_put db_exists db_get db_pget db_del db_key_range
78	db_txn_commit db_txn_abort	123	db_txn_commit db_txn_abort db_txn_finish
79	db_c_close db_c_count db_c_put db_c_get db_c_pget db_c_del	124	db_c_close db_c_count db_c_put db_c_get db_c_pget db_c_del
80	db_sequence_open db_sequence_close	125	db_sequence_open db_sequence_close
81	db_sequence_get db_sequence_remove	126	db_sequence_get db_sequence_remove
82	);	127	);
83	our @EXPORT = (@BDB_REQ, qw(dbreq_pri dbreq_nice db_env_create db_create));	128	our @EXPORT = (@BDB_REQ, qw(dbreq_pri dbreq_nice db_env_create db_create));
…		…
90		135
91	require XSLoader;	136	require XSLoader;
92	XSLoader::load ("BDB", $VERSION);	137	XSLoader::load ("BDB", $VERSION);
93	}	138	}
94		139
		140	=head1 BERKELEYDB FUNCTIONS
		141
		142	All of these are functions. The create functions simply return a new
		143	object and never block. All the remaining functions take an optional
		144	callback as last argument. If it is missing, then the function will be
		145	executed synchronously. In both cases, C<$!> will reflect the return value
		146	of the function.
		147
		148	BDB functions that cannot block (mostly functions that manipulate
		149	settings) are method calls on the relevant objects, so the rule of thumb
		150	is: if it's a method, it's not blocking, if it's a function, it takes a
		151	callback as last argument.
		152
		153	In the following, C<$int> signifies an integer return value,
		154	C<bdb_filename> is a "filename" (octets on unix, madness on windows),
		155	C<U32> is an unsigned 32 bit integer, C<int> is some integer, C<NV> is a
		156	floating point value.
		157
		158	Most C<SV *> types are generic perl scalars (for input and output of data
		159	values).
		160
		161	The various C<DB_ENV> etc. arguments are handles return by
		162	C<db_env_create>, C<db_create>, C<txn_begin> and so on. If they have an
		163	appended C<_ornull> this means they are optional and you can pass C<undef>
		164	for them, resulting a NULL pointer on the C level.
		165
		166	The C<SV *callback> is the optional callback function to call when the
		167	request is completed. This last callback argument is special: the callback
		168	is simply the last argument passed. If there are "optional" arguments
		169	before the callback they can be left out. The callback itself can be left
		170	out or specified as C<undef>, in which case the function will be executed
		171	synchronously.
		172
		173	For example, C<db_env_txn_checkpoint> usually is called with all integer
		174	arguments zero. These can be left out, so all of these specify a call
		175	to C<< DB_ENV->txn_checkpoint >>, to be executed asynchronously with a
		176	callback to be called:
		177
		178	db_env_txn_checkpoint $db_env, 0, 0, 0, sub { };
		179	db_env_txn_checkpoint $db_env, 0, 0, sub { };
		180	db_env_txn_checkpoint $db_env, sub { };
		181
		182	While these all specify a call to C<< DB_ENV->txn_checkpoint >> to be
		183	executed synchronously:
		184
		185	db_env_txn_checkpoint $db_env, 0, 0, 0, undef;
		186	db_env_txn_checkpoint $db_env, 0, 0, 0;
		187	db_env_txn_checkpoint $db_env, 0;
		188
		189	=head2 BDB functions
		190
		191	Functions in the BDB namespace, exported by default:
		192
		193	$env = db_env_create (U32 env_flags = 0)
		194	flags: RPCCLIENT
		195
		196	db_env_open (DB_ENV env, bdb_filename db_home, U32 open_flags, int mode, SV callback = 0)
		197	open_flags: INIT_CDB INIT_LOCK INIT_LOG INIT_MPOOL INIT_REP INIT_TXN RECOVER RECOVER_FATAL USE_ENVIRON USE_ENVIRON_ROOT CREATE LOCKDOWN PRIVATE REGISTER SYSTEM_MEM
		198	db_env_close (DB_ENV env, U32 flags = 0, SV callback = 0)
		199	db_env_txn_checkpoint (DB_ENV env, U32 kbyte = 0, U32 min = 0, U32 flags = 0, SV callback = 0)
		200	flags: FORCE
		201	db_env_lock_detect (DB_ENV env, U32 flags = 0, U32 atype = DB_LOCK_DEFAULT, SV dummy = 0, SV *callback = 0)
		202	atype: LOCK_DEFAULT LOCK_EXPIRE LOCK_MAXLOCKS LOCK_MAXWRITE LOCK_MINLOCKS LOCK_MINWRITE LOCK_OLDEST LOCK_RANDOM LOCK_YOUNGEST
		203	db_env_memp_sync (DB_ENV env, SV dummy = 0, SV *callback = 0)
		204	db_env_memp_trickle (DB_ENV env, int percent, SV dummy = 0, SV *callback = 0)
		205	db_env_dbremove (DB_ENV env, DB_TXN_ornull txnid, bdb_filename file, bdb_filename database, U32 flags = 0, SV *callback = 0)
		206	db_env_dbrename (DB_ENV env, DB_TXN_ornull txnid, bdb_filename file, bdb_filename database, bdb_filename newname, U32 flags = 0, SV *callback = 0)
		207	db_env_log_archive (DB_ENV env, SV listp, U32 flags = 0, SV *callback = 0)
		208
		209	$db = db_create (DB_ENV *env = 0, U32 flags = 0)
		210	flags: XA_CREATE
		211
		212	db_open (DB db, DB_TXN_ornull txnid, bdb_filename file, bdb_filename database, int type, U32 flags, int mode, SV *callback = 0)
		213	flags: AUTO_COMMIT CREATE EXCL MULTIVERSION NOMMAP RDONLY READ_UNCOMMITTED THREAD TRUNCATE
		214	db_close (DB db, U32 flags = 0, SV callback = 0)
		215	flags: DB_NOSYNC
		216	db_verify (DB db, bdb_filename file, bdb_filename database = 0, SV dummy = 0, U32 flags = 0, SV *callback = 0)
		217	db_upgrade (DB db, bdb_filename file, U32 flags = 0, SV callback = 0)
		218	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 = 0)
		219	flags: FREELIST_ONLY FREE_SPACE
		220	db_sync (DB db, U32 flags = 0, SV callback = 0)
		221	db_key_range (DB db, DB_TXN_ornull txn, SV key, SV key_range, U32 flags = 0, SV *callback = 0)
		222	db_put (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = 0)
		223	flags: APPEND NODUPDATA NOOVERWRITE
		224	db_exists (DB db, DB_TXN_ornull txn, SV key, U32 flags = 0, SV callback = 0) (v4.6)
		225	db_get (DB db, DB_TXN_ornull txn, SV key, SV data, U32 flags = 0, SV *callback = 0)
		226	flags: CONSUME CONSUME_WAIT GET_BOTH SET_RECNO MULTIPLE READ_COMMITTED READ_UNCOMMITTED RMW
		227	db_pget (DB db, DB_TXN_ornull txn, SV key, SV pkey, SV data, U32 flags = 0, SV callback = 0)
		228	flags: CONSUME CONSUME_WAIT GET_BOTH SET_RECNO MULTIPLE READ_COMMITTED READ_UNCOMMITTED RMW
		229	db_del (DB db, DB_TXN_ornull txn, SV key, U32 flags = 0, SV callback = 0)
		230	db_txn_commit (DB_TXN txn, U32 flags = 0, SV callback = 0)
		231	flags: TXN_NOSYNC TXN_SYNC
		232	db_txn_abort (DB_TXN txn, SV callback = 0)
		233
		234	db_c_close (DBC dbc, SV callback = 0)
		235	db_c_count (DBC dbc, SV count, U32 flags = 0, SV *callback = 0)
		236	db_c_put (DBC dbc, SV key, SV data, U32 flags = 0, SV callback = 0)
		237	flags: AFTER BEFORE CURRENT KEYFIRST KEYLAST NODUPDATA
		238	db_c_get (DBC dbc, SV key, SV data, U32 flags = 0, SV callback = 0)
		239	flags: CURRENT FIRST GET_BOTH GET_BOTH_RANGE GET_RECNO JOIN_ITEM LAST NEXT NEXT_DUP NEXT_NODUP PREV PREV_DUP PREV_NODUP SET SET_RANGE SET_RECNO READ_UNCOMMITTED MULTIPLE MULTIPLE_KEY RMW
		240	db_c_pget (DBC dbc, SV key, SV pkey, SV data, U32 flags = 0, SV *callback = 0)
		241	db_c_del (DBC dbc, U32 flags = 0, SV callback = 0)
		242
		243	db_sequence_open (DB_SEQUENCE seq, DB_TXN_ornull txnid, SV key, U32 flags = 0, SV callback = 0)
		244	flags: CREATE EXCL
		245	db_sequence_close (DB_SEQUENCE seq, U32 flags = 0, SV callback = 0)
		246	db_sequence_get (DB_SEQUENCE seq, DB_TXN_ornull txnid, int delta, SV seq_value, U32 flags = DB_TXN_NOSYNC, SV callback = 0)
		247	flags: TXN_NOSYNC
		248	db_sequence_remove (DB_SEQUENCE seq, DB_TXN_ornull txnid = 0, U32 flags = 0, SV *callback = 0)
		249	flags: TXN_NOSYNC
		250
		251	=head3 db_txn_finish (DB_TXN txn, U32 flags = 0, SV callback = 0)
		252
		253	This is not actually a Berkeley DB function but a BDB module
		254	extension. The background for this exytension is: It is very annoying to
		255	have to check every single BDB function for error returns and provide a
		256	codepath out of your transaction. While the BDB module still makes this
		257	possible, it contains the following extensions:
		258
		259	When a transaction-protected function returns any operating system
		260	error (errno > 0), BDB will set the C<TXN_DEADLOCK> flag on the
		261	transaction. This flag is also set by Berkeley DB functions themselves
		262	when an operation fails with LOCK_DEADLOCK, and it causes all further
		263	operations on that transaction (including C<db_txn_commit>) to fail.
		264
		265	The C<db_txn_finish> request will look at this flag, and, if it is set,
		266	will automatically call C<db_txn_abort> (setting errno to C<LOCK_DEADLOCK>
		267	if it isn't set to something else yet). If it isn't set, it will call
		268	C<db_txn_commit> and return the error normally.
		269
		270	How to use this? Easy: just write your transaction normally:
		271
		272	my $txn = $db_env->txn_begin;
		273	db_get $db, $txn, "key", my $data;
		274	db_put $db, $txn, "key", $data + 1 unless $! == BDB::NOTFOUND;
		275	db_txn_finish $txn;
		276	die "transaction failed" if $!;
		277
		278	That is, handle only the expected errors. If something unexpected happens
		279	(EIO, LOCK_NOTGRANTED or a deadlock in either db_get or db_put), then the remaining
		280	requests (db_put in this case) will simply be skipped (they will fail with
		281	LOCK_DEADLOCK) and the transaction will be aborted.
		282
		283	You can use the C<< $txn->failed >> method to check wether a transaction
		284	has failed in this way and abort further processing (excluding
		285	C<db_txn_finish>).
		286
		287
		288	=head2 DB_ENV/database environment methods
		289
		290	Methods available on DB_ENV/$env handles:
		291
		292	DESTROY (DB_ENV_ornull *env)
		293	CODE:
		294	if (env)
		295	env->close (env, 0);
		296
		297	$int = $env->set_data_dir (const char *dir)
		298	$int = $env->set_tmp_dir (const char *dir)
		299	$int = $env->set_lg_dir (const char *dir)
		300	$int = $env->set_shm_key (long shm_key)
		301	$int = $env->set_cachesize (U32 gbytes, U32 bytes, int ncache = 0)
		302	$int = $env->set_flags (U32 flags, int onoff = 1)
		303	$int = $env->log_set_config (U32 flags, int onoff = 1) (v4.7)
		304	$int = $env->set_intermediate_dir_mode (const char *modestring) (v4.7)
		305	$env->set_errfile (FILE *errfile = 0)
		306	$env->set_msgfile (FILE *msgfile = 0)
		307	$int = $env->set_verbose (U32 which, int onoff = 1)
		308	$int = $env->set_encrypt (const char *password, U32 flags = 0)
		309	$int = $env->set_timeout (NV timeout_seconds, U32 flags = SET_TXN_TIMEOUT)
		310	$int = $env->set_mp_max_openfd (int maxopenfd);
		311	$int = $env->set_mp_max_write (int maxwrite, int maxwrite_sleep);
		312	$int = $env->set_mp_mmapsize (int mmapsize_mb)
		313	$int = $env->set_lk_detect (U32 detect = DB_LOCK_DEFAULT)
		314	$int = $env->set_lk_max_lockers (U32 max)
		315	$int = $env->set_lk_max_locks (U32 max)
		316	$int = $env->set_lk_max_objects (U32 max)
		317	$int = $env->set_lg_bsize (U32 max)
		318	$int = $env->set_lg_max (U32 max)
		319	$int = $env->mutex_set_increment (U32 increment)
		320	$int = $env->mutex_set_tas_spins (U32 tas_spins)
		321	$int = $env->mutex_set_max (U32 max)
		322	$int = $env->mutex_set_align (U32 align)
		323
		324	$txn = $env->txn_begin (DB_TXN_ornull *parent = 0, U32 flags = 0)
		325	flags: READ_COMMITTED READ_UNCOMMITTED TXN_NOSYNC TXN_NOWAIT TXN_SNAPSHOT TXN_SYNC TXN_WAIT TXN_WRITE_NOSYNC
		326	$txn = $env->cdsgroup_begin; (v4.5)
		327
		328	=head3 Example:
		329
		330	use AnyEvent;
		331	use BDB;
		332
		333	our $FH; open $FH, "<&=" . BDB::poll_fileno;
		334	our $WATCHER = AnyEvent->io (fh => $FH, poll => 'r', cb => \&BDB::poll_cb);
		335
		336	BDB::min_parallel 8;
		337
		338	my $env = db_env_create;
		339
		340	mkdir "bdtest", 0700;
		341	db_env_open
		342	$env,
		343	"bdtest",
		344	BDB::INIT_LOCK \| BDB::INIT_LOG \| BDB::INIT_MPOOL \| BDB::INIT_TXN \| BDB::RECOVER \| BDB::USE_ENVIRON \| BDB::CREATE,
		345	0600;
		346
		347	$env->set_flags (BDB::AUTO_COMMIT \| BDB::TXN_NOSYNC, 1);
		348
		349
		350	=head2 DB/database methods
		351
		352	Methods available on DB/$db handles:
		353
		354	DESTROY (DB_ornull *db)
		355	CODE:
		356	if (db)
		357	{
		358	SV env = (SV )db->app_private;
		359	db->close (db, 0);
		360	SvREFCNT_dec (env);
		361	}
		362
		363	$int = $db->set_cachesize (U32 gbytes, U32 bytes, int ncache = 0)
		364	$int = $db->set_flags (U32 flags)
		365	flags: CHKSUM ENCRYPT TXN_NOT_DURABLE
		366	Btree: DUP DUPSORT RECNUM REVSPLITOFF
		367	Hash: DUP DUPSORT
		368	Queue: INORDER
		369	Recno: RENUMBER SNAPSHOT
		370
		371	$int = $db->set_encrypt (const char *password, U32 flags)
		372	$int = $db->set_lorder (int lorder)
		373	$int = $db->set_bt_minkey (U32 minkey)
		374	$int = $db->set_re_delim (int delim)
		375	$int = $db->set_re_pad (int re_pad)
		376	$int = $db->set_re_source (char *source)
		377	$int = $db->set_re_len (U32 re_len)
		378	$int = $db->set_h_ffactor (U32 h_ffactor)
		379	$int = $db->set_h_nelem (U32 h_nelem)
		380	$int = $db->set_q_extentsize (U32 extentsize)
		381
		382	$dbc = $db->cursor (DB_TXN_ornull *txn = 0, U32 flags = 0)
		383	flags: READ_COMMITTED READ_UNCOMMITTED WRITECURSOR TXN_SNAPSHOT
		384	$seq = $db->sequence (U32 flags = 0)
		385
		386	=head3 Example:
		387
		388	my $db = db_create $env;
		389	db_open $db, undef, "table", undef, BDB::BTREE, BDB::AUTO_COMMIT \| BDB::CREATE \| BDB::READ_UNCOMMITTED, 0600;
		390
		391	for (1..1000) {
		392	db_put $db, undef, "key $_", "data $_";
		393
		394	db_key_range $db, undef, "key $_", my $keyrange;
		395	my ($lt, $eq, $gt) = @$keyrange;
		396	}
		397
		398	db_del $db, undef, "key $_" for 1..1000;
		399
		400	db_sync $db;
		401
		402
		403	=head2 DB_TXN/transaction methods
		404
		405	Methods available on DB_TXN/$txn handles:
		406
		407	DESTROY (DB_TXN_ornull *txn)
		408	CODE:
		409	if (txn)
		410	txn->abort (txn);
		411
		412	$int = $txn->set_timeout (NV timeout_seconds, U32 flags = SET_TXN_TIMEOUT)
		413	flags: SET_LOCK_TIMEOUT SET_TXN_TIMEOUT
		414
		415	$bool = $txn->failed
		416	# see db_txn_finish documentation, above
		417
		418
		419	=head2 DBC/cursor methods
		420
		421	Methods available on DBC/$dbc handles:
		422
		423	DESTROY (DBC_ornull *dbc)
		424	CODE:
		425	if (dbc)
		426	dbc->c_close (dbc);
		427
		428	$int = $cursor->set_priority ($priority = PRIORITY_*) (v4.6)
		429
		430	=head3 Example:
		431
		432	my $c = $db->cursor;
		433
		434	for (;;) {
		435	db_c_get $c, my $key, my $data, BDB::NEXT;
		436	warn "<$!,$key,$data>";
		437	last if $!;
		438	}
		439
		440	db_c_close $c;
		441
		442
		443	=head2 DB_SEQUENCE/sequence methods
		444
		445	Methods available on DB_SEQUENCE/$seq handles:
		446
		447	DESTROY (DB_SEQUENCE_ornull *seq)
		448	CODE:
		449	if (seq)
		450	seq->close (seq, 0);
		451
		452	$int = $seq->initial_value (db_seq_t value)
		453	$int = $seq->set_cachesize (U32 size)
		454	$int = $seq->set_flags (U32 flags)
		455	flags: SEQ_DEC SEQ_INC SEQ_WRAP
		456	$int = $seq->set_range (db_seq_t min, db_seq_t max)
		457
		458	=head3 Example:
		459
		460	my $seq = $db->sequence;
		461
		462	db_sequence_open $seq, undef, "seq", BDB::CREATE;
		463	db_sequence_get $seq, undef, 1, my $value;
		464
		465
95	=head2 SUPPORT FUNCTIONS	466	=head1 SUPPORT FUNCTIONS
96		467
97	=head3 EVENT PROCESSING AND EVENT LOOP INTEGRATION	468	=head2 EVENT PROCESSING AND EVENT LOOP INTEGRATION
98		469
99	=over 4	470	=over 4
		471
		472	=item $msg = BDB::strerror [$errno]
		473
		474	Returns the string corresponding to the given errno value. If no argument
		475	is given, use C<$!>.
		476
		477	Note that the BDB module also patches the C<$!> variable directly, so you
		478	should be able to get a bdb error string by simply stringifying C<$!>.
100		479
101	=item $fileno = BDB::poll_fileno	480	=item $fileno = BDB::poll_fileno
102		481
103	Return the I<request result pipe file descriptor>. This filehandle must be	482	Return the I<request result pipe file descriptor>. This filehandle must be
104	polled for reading by some mechanism outside this module (e.g. Event or	483	polled for reading by some mechanism outside this module (e.g. Event or
…		…
143	interactiveness when perl is not fast enough to process all requests in	522	interactiveness when perl is not fast enough to process all requests in
144	time.	523	time.
145		524
146	For interactive programs, values such as C<0.01> to C<0.1> should be fine.	525	For interactive programs, values such as C<0.01> to C<0.1> should be fine.
147		526
148	Example: Install an Event watcher that automatically calls	527	Example: Install an EV watcher that automatically calls
149	BDB::poll_cb with low priority, to ensure that other parts of the	528	BDB::poll_cb with low priority, to ensure that other parts of the
150	program get the CPU sometimes even under high AIO load.	529	program get the CPU sometimes even under high load.
151		530
152	# try not to spend much more than 0.1s in poll_cb	531	# try not to spend much more than 0.1s in poll_cb
153	BDB::max_poll_time 0.1;	532	BDB::max_poll_time 0.1;
154		533
155	# use a low priority so other tasks have priority	534	my $bdb_poll = EV::io BDB::poll_fileno, EV::READ, \&BDB::poll_cb);
156	Event->io (fd => BDB::poll_fileno,
157	poll => 'r', nice => 1,
158	cb => &BDB::poll_cb);
159		535
160	=item BDB::poll_wait	536	=item BDB::poll_wait
161		537
162	If there are any outstanding requests and none of them in the result	538	If there are any outstanding requests and none of them in the result
163	phase, wait till the result filehandle becomes ready for reading (simply	539	phase, wait till the result filehandle becomes ready for reading (simply
…		…
175		551
176	BDB::poll_wait, BDB::poll_cb	552	BDB::poll_wait, BDB::poll_cb
177		553
178	=item BDB::flush	554	=item BDB::flush
179		555
180	Wait till all outstanding AIO requests have been handled.	556	Wait till all outstanding BDB requests have been handled.
181		557
182	Strictly equivalent to:	558	Strictly equivalent to:
183		559
184	BDB::poll_wait, BDB::poll_cb	560	BDB::poll_wait, BDB::poll_cb
185	while BDB::nreqs;	561	while BDB::nreqs;
186		562
		563	=back
		564
		565	=head2 VERSION CHECKING
		566
		567	BerkeleyDB comes in various versions, many of them have minor
		568	incompatibilities. This means that traditional "at least version x.x"
		569	checks are often not sufficient.
		570
		571	Example: set the log_autoremove option in a way compatible with <v4.7 and
		572	v4.7. Note the use of & on the constants to avoid triggering a compiletime
		573	bug when the symbol isn't available.
		574
		575	$DB_ENV->set_flags (&BDB::LOG_AUTOREMOVE ) if BDB::VERSION v0, v4.7;
		576	$DB_ENV->log_set_config (&BDB::LOG_AUTO_REMOVE) if BDB::VERSION v4.7;
		577
		578	=over 4
		579
		580	=item BDB::VERSION
		581
		582	The C<BDB::VERSION> function, when called without arguments, returns the
		583	Berkeley DB version as a v-string (usually with 3 components). You should
		584	use C<lt> and C<ge> operators exclusively to make comparisons.
		585
		586	Example: check for at least version 4.7.
		587
		588	BDB::VERSION ge v4.7 or die;
		589
		590	=item BDB::VERSION min-version
		591
		592	Returns true if the BDB version is at least the given version (specified
		593	as a v-string), false otherwise.
		594
		595	Example: check for at least version 4.5.
		596
		597	BDB::VERSION v4.7 or die;
		598
		599	=item BDB::VERSION min-version, max-version
		600
		601	Returns true of the BDB version is at least version C<min-version> (specify C<undef> or C<v0> for any minimum version)
		602	and less then C<max-version>.
		603
		604	Example: check wether version is strictly less then v4.7.
		605
		606	BDB::VERSION v0, v4.7
		607	or die "version 4.7 is not yet supported";
		608
		609	=back
		610
		611	=cut
		612
		613	sub VERSION {
		614	# I was dumb enough to override the VERSION method here, so let's try
		615	# to fix it up.
		616
		617	if ($_[0] eq __PACKAGE__) {
		618	$VERSION
		619	} else {
		620	if (@_ > 0) {
		621	return undef if VERSION_v lt $_[0];
		622	if (@_ > 1) {
		623	return undef if VERSION_v ge $_[1];
		624	}
		625	}
		626
		627	VERSION_v
		628	}
		629	}
		630
187	=head3 CONTROLLING THE NUMBER OF THREADS	631	=head2 CONTROLLING THE NUMBER OF THREADS
		632
		633	=over 4
188		634
189	=item BDB::min_parallel $nthreads	635	=item BDB::min_parallel $nthreads
190		636
191	Set the minimum number of AIO threads to C<$nthreads>. The current	637	Set the minimum number of BDB threads to C<$nthreads>. The current
192	default is C<8>, which means eight asynchronous operations can execute	638	default is C<8>, which means eight asynchronous operations can execute
193	concurrently at any one time (the number of outstanding requests,	639	concurrently at any one time (the number of outstanding requests,
194	however, is unlimited).	640	however, is unlimited).
195		641
196	BDB starts threads only on demand, when an AIO request is queued and	642	BDB starts threads only on demand, when an BDB request is queued and
197	no free thread exists. Please note that queueing up a hundred requests can	643	no free thread exists. Please note that queueing up a hundred requests can
198	create demand for a hundred threads, even if it turns out that everything	644	create demand for a hundred threads, even if it turns out that everything
199	is in the cache and could have been processed faster by a single thread.	645	is in the cache and could have been processed faster by a single thread.
200		646
201	It is recommended to keep the number of threads relatively low, as some	647	It is recommended to keep the number of threads relatively low, as some
…		…
206	Under most circumstances you don't need to call this function, as the	652	Under most circumstances you don't need to call this function, as the
207	module selects a default that is suitable for low to moderate load.	653	module selects a default that is suitable for low to moderate load.
208		654
209	=item BDB::max_parallel $nthreads	655	=item BDB::max_parallel $nthreads
210		656
211	Sets the maximum number of AIO threads to C<$nthreads>. If more than the	657	Sets the maximum number of BDB threads to C<$nthreads>. If more than the
212	specified number of threads are currently running, this function kills	658	specified number of threads are currently running, this function kills
213	them. This function blocks until the limit is reached.	659	them. This function blocks until the limit is reached.
214		660
215	While C<$nthreads> are zero, aio requests get queued but not executed	661	While C<$nthreads> are zero, aio requests get queued but not executed
216	until the number of threads has been increased again.	662	until the number of threads has been increased again.
…		…
251		697
252	You can still queue as many requests as you want. Therefore,	698	You can still queue as many requests as you want. Therefore,
253	C<max_oustsanding> is mainly useful in simple scripts (with low values) or	699	C<max_oustsanding> is mainly useful in simple scripts (with low values) or
254	as a stop gap to shield against fatal memory overflow (with large values).	700	as a stop gap to shield against fatal memory overflow (with large values).
255		701
256	=item BDB::set_sync_prepare $cb	702	=item $old_cb = BDB::set_sync_prepare $cb
257		703
258	Sets a callback that is called whenever a request is created without an	704	Sets a callback that is called whenever a request is created without an
259	explicit callback. It has to return two code references. The first is used	705	explicit callback. It has to return two code references. The first is used
260	as the request callback, and the second is called to wait until the first	706	as the request callback (it should save the return status), and the second
261	callback has been called. The default implementation works like this:	707	is called to wait until the first callback has been called (it must set
		708	C<$!> to the return status).
		709
		710	This mechanism can be used to include BDB into other event mechanisms,
		711	such as L<Coro::BDB>.
		712
		713	To allow other, callback-based, events to be executed while callback-less
		714	ones are run, you could use this sync prepare function:
262		715
263	sub {	716	sub {
264	my $status;	717	my $status;
265	(	718	(
266	sub { $status = $! },	719	sub { $status = $! },
267	sub { BDB::poll while !defined $status; $! = $status },	720	sub { BDB::poll while !defined $status; $! = $status },
268	)	721	)
269	}	722	}
270		723
		724	It works by polling for results till the request has finished and then
		725	sets C<$!> to the return value. This means that if you don't use a
		726	callback, BDB would simply fall back to synchronous operations.
		727
		728	By default, or if the sync prepare function is set to C<undef>, is to
		729	execute callback-less BDB requests in the foreground thread, setting C<$!>
		730	to the return value, without polling for other events.
		731
271	=back	732	=back
272		733
273	=head3 STATISTICAL INFORMATION	734	=head2 STATISTICAL INFORMATION
274		735
275	=over 4	736	=over 4
276		737
277	=item BDB::nreqs	738	=item BDB::nreqs
278		739
…		…
296		757
297	=back	758	=back
298		759
299	=cut	760	=cut
300		761
301	set_sync_prepare {	762	set_sync_prepare (undef);
302	my $status;
303	(
304	sub {
305	$status = $!;
306	},
307	sub {
308	BDB::poll while !defined $status;
309	$! = $status;
310	},
311	)
312	};
313		763
314	min_parallel 8;	764	min_parallel 8;
315		765
316	END { flush }	766	END { flush }
317		767
318	1;	768	1;
319		769
		770	=head1 COMMON PITFALLS
		771
		772	=head2 Unexpected Crashes
		773
		774	Remember that, by default, BDB will execute requests in parallel, in
		775	somewhat random order. That means that it is easy to run a C<db_get>
		776	request on thesa me database as a concurrent C<db_close> request, leading
		777	to a crash, silent data corruption, eventually the next world war on
		778	terrorism.
		779
		780	If you only ever use foreground requests (without a callback), this will
		781	not be an issue.
		782
		783	=head2 Unexpected Freezes or Deadlocks
		784
		785	Remember that, by default, BDB will execute requests in parallel, which
		786	easily leads to deadlocks (even concurrent put's on the same database can
		787	deadlock).
		788
		789	You either need to run deadlock detection (and handle the resulting
		790	errors), or make sure only one process ever updates the database, ine one
		791	thread, e.g. by using only foreground requests (without a callback).
		792
320	=head2 FORK BEHAVIOUR	793	=head1 FORK BEHAVIOUR
321		794
322	This module should do "the right thing" when the process using it forks:	795	This module should do "the right thing" when the process using it forks:
323		796
324	Before the fork, IO::AIO enters a quiescent state where no requests	797	Before the fork, BDB enters a quiescent state where no requests
325	can be added in other threads and no results will be processed. After	798	can be added in other threads and no results will be processed. After
326	the fork the parent simply leaves the quiescent state and continues	799	the fork the parent simply leaves the quiescent state and continues
327	request/result processing, while the child frees the request/result queue	800	request/result processing, while the child frees the request/result queue
328	(so that the requests started before the fork will only be handled in the	801	(so that the requests started before the fork will only be handled in the
329	parent). Threads will be started on demand until the limit set in the	802	parent). Threads will be started on demand until the limit set in the
330	parent process has been reached again.	803	parent process has been reached again.
331		804
332	In short: the parent will, after a short pause, continue as if fork had	805	In short: the parent will, after a short pause, continue as if fork had
333	not been called, while the child will act as if IO::AIO has not been used	806	not been called, while the child will act as if BDB has not been used
334	yet.	807	yet.
335		808
		809	Win32 note: there is no fork on win32, and perls emulation of it is too
		810	broken to be supported, so do not use BDB in a windows pseudo-fork, better
		811	yet, switch to a more capable platform.
		812
336	=head2 MEMORY USAGE	813	=head1 MEMORY USAGE
337		814
338	Per-request usage:	815	Per-request usage:
339		816
340	Each aio request uses - depending on your architecture - around 100-200	817	Each aio request uses - depending on your architecture - around 100-200
341	bytes of memory. In addition, stat requests need a stat buffer (possibly	818	bytes of memory. In addition, stat requests need a stat buffer (possibly
342	a few hundred bytes), readdir requires a result buffer and so on. Perl	819	a few hundred bytes), readdir requires a result buffer and so on. Perl
343	scalars and other data passed into aio requests will also be locked and	820	scalars and other data passed into aio requests will also be locked and
344	will consume memory till the request has entered the done state.	821	will consume memory till the request has entered the done state.
345		822
346	This is now awfully much, so queuing lots of requests is not usually a	823	This is not awfully much, so queuing lots of requests is not usually a
347	problem.	824	problem.
348		825
349	Per-thread usage:	826	Per-thread usage:
350		827
351	In the execution phase, some aio requests require more memory for	828	In the execution phase, some aio requests require more memory for
352	temporary buffers, and each thread requires a stack and other data	829	temporary buffers, and each thread requires a stack and other data
353	structures (usually around 16k-128k, depending on the OS).	830	structures (usually around 16k-128k, depending on the OS).
354		831
		832	=head1 WIN32 FILENAMES/DATABASE NAME MESS
		833
		834	Perl on Win32 supports only ASCII filenames (the reason is that it abuses
		835	an internal flag to store wether a filename is Unicode or ANSI, but that
		836	flag is used for somethign else in the perl core, so there is no way to
		837	detect wether a filename is ANSI or Unicode-encoded). The BDB module
		838	tries to work around this issue by assuming that the filename is an ANSI
		839	filename and BDB was built for unicode support.
		840
355	=head1 KNOWN BUGS	841	=head1 KNOWN BUGS
356		842
357	Known bugs will be fixed in the next release.	843	Known bugs will be fixed in the next release, except:
		844
		845	If you use a transaction in any request, and the request returns
		846	with an operating system error or DB_LOCK_NOTGRANTED, the internal
		847	TXN_DEADLOCK flag will be set on the transaction. See C<db_txn_finish>,
		848	above.
358		849
359	=head1 SEE ALSO	850	=head1 SEE ALSO
360		851
361	L<Coro::AIO>.	852	L<AnyEvent::BDB> (event loop integration), L<Coro::BDB> (more natural
		853	syntax), L<IO::AIO> (nice to have).
362		854
363	=head1 AUTHOR	855	=head1 AUTHOR
364		856
365	Marc Lehmann <schmorp@schmorp.de>	857	Marc Lehmann <schmorp@schmorp.de>
366	http://home.schmorp.de/	858	http://home.schmorp.de/

Diff Legend

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

Comparing BDB/BDB.pm (file contents): Revision 1.7 by root, Mon Mar 5 19:47:01 2007 UTC vs. Revision 1.57 by root, Tue Jul 14 19:29:23 2009 UTC

Diff Legend

Comparing BDB/BDB.pm (file contents):
Revision 1.7 by root, Mon Mar 5 19:47:01 2007 UTC vs.
Revision 1.57 by root, Tue Jul 14 19:29:23 2009 UTC