ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent-DBI/DBI.pm
(Generate patch)

Comparing AnyEvent-DBI/DBI.pm (file contents):
Revision 1.1 by root, Fri Jun 6 15:35:46 2008 UTC vs.
Revision 1.22 by root, Mon Apr 23 16:31:26 2018 UTC

… …
3AnyEvent::DBI - asynchronous DBI access 3AnyEvent::DBI - asynchronous DBI access
4 4
5=head1 SYNOPSIS 5=head1 SYNOPSIS
6 6
7 use AnyEvent::DBI; 7 use AnyEvent::DBI;
8
9 my $cv = AnyEvent->condvar;
10
11 my $dbh = new AnyEvent::DBI "DBI:SQLite:dbname=test.db", "", "";
12
13 $dbh->exec ("select * from test where num=?", 10, sub {
14 my ($dbh, $rows, $rv) = @_;
15
16 $#_ or die "failure: $@";
17
18 print "@$_\n"
19 for @$rows;
20
21 $cv->broadcast;
22 });
23
24 # asynchronously do sth. else here
25
26 $cv->wait;
8 27
9=head1 DESCRIPTION 28=head1 DESCRIPTION
10 29
11This module is an L<AnyEvent> user, you need to make sure that you use and 30This module is an L<AnyEvent> user, you need to make sure that you use and
12run a supported event loop. 31run a supported event loop.
13 32
14This module implements asynchronous DBI access my forking or executing 33This module implements asynchronous DBI access by forking or executing
15separate "DBI-Server" processes and sending them requests. 34separate "DBI-Server" processes and sending them requests.
16 35
17It means that you can run DBI requests in parallel to other tasks. 36It means that you can run DBI requests in parallel to other tasks.
18 37
38With DBD::mysql, the overhead for very simple statements
39("select 0") is somewhere around 50% compared to an explicit
40prepare_cached/execute/fetchrow_arrayref/finish combination. With
41DBD::SQlite3, it's more like a factor of 8 for this trivial statement.
42
43=head2 ERROR HANDLING
44
45This module defines a number of functions that accept a callback
46argument. All callbacks used by this module get their AnyEvent::DBI handle
47object passed as first argument.
48
49If the request was successful, then there will be more arguments,
50otherwise there will only be the C<$dbh> argument and C<$@> contains an
51error message.
52
53A convenient way to check whether an error occurred is to check C<$#_> -
54if that is true, then the function was successful, otherwise there was an
55error.
56
19=cut 57=cut
20 58
21package AnyEvent::DBI; 59package AnyEvent::DBI;
22 60
23use strict; 61use common::sense;
24no warnings;
25 62
26use Carp; 63use Carp;
27use Socket (); 64use Convert::Scalar ();
28use Scalar::Util (); 65use AnyEvent::Fork ();
29use Storable (); 66use CBOR::XS ();
30
31use DBI ();
32 67
33use AnyEvent (); 68use AnyEvent ();
34use AnyEvent::Util (); 69use AnyEvent::Util ();
35 70
71use Errno ();
72
36our $VERSION = '1.0'; 73our $VERSION = '3.04';
37
38# this is the forked server code
39
40our $DBH;
41
42sub req_open {
43 my (undef, $dbi, $user, $pass, %attr) = @{+shift};
44
45 $DBH = DBI->connect ($dbi, $user, $pass, \%attr);
46
47 [1]
48}
49
50sub serve {
51 my ($fh) = @_;
52
53 no strict;
54
55 eval {
56 my $rbuf;
57
58 while () {
59 sysread $fh, $rbuf, 16384, length $rbuf
60 or last;
61
62 while () {
63 my $len = unpack "L", $rbuf;
64
65 # full request available?
66 last unless $len && $len + 4 <= length $rbuf;
67
68 my $req = Storable::thaw substr $rbuf, 4;
69 substr $rbuf, 0, $len + 4, ""; # remove length + request
70
71 my $wbuf = eval { pack "L/a*", Storable::freeze $req->[0]($req) };
72
73 $wbuf = pack "L/a*", Storable::freeze [undef, "$@"]
74 if $@;
75
76 for (my $ofs = 0; $ofs < length $wbuf; ) {
77 $ofs += (syswrite $fh, substr $wbuf, $ofs
78 or die "unable to write results");
79 }
80 }
81 }
82 };
83
84 warn $@;#d#
85
86 kill 9, $$; # no other way on the broken windows platform
87}
88 74
89=head2 METHODS 75=head2 METHODS
90 76
91=over 4 77=over 4
92 78
… …
113 99
114When an error occurs, then this callback will be invoked. On entry, C<$@> 100When an error occurs, then this callback will be invoked. On entry, C<$@>
115is set to the error message. C<$filename> and C<$line> is where the 101is set to the error message. C<$filename> and C<$line> is where the
116original request was submitted. 102original request was submitted.
117 103
118If this callback returns and this was a fatal error (C<$fatal> is true) 104If the fatal argument is true then the database connection is shut down
119then AnyEvent::DBI die's, otherwise it calls the original request callback 105and your database handle became invalid. In addition to invoking the
120without any arguments. 106C<on_error> callback, all of your queued request callbacks are called
107without only the C<$dbh> argument.
121 108
122If omitted, then C<die> will be called on any fatal errors, others will be ignored. 109If omitted, then C<die> will be called on any errors, fatal or not.
110
111=item on_connect => $callback->($dbh[, $success])
112
113If you supply an C<on_connect> callback, then this callback will be
114invoked after the database connect attempt. If the connection succeeds,
115C<$success> is true, otherwise it is missing and C<$@> contains the
116C<$DBI::errstr>.
117
118Regardless of whether C<on_connect> is supplied, connect errors will result in
119C<on_error> being called. However, if no C<on_connect> callback is supplied, then
120connection errors are considered fatal. The client will C<die> and the C<on_error>
121callback will be called with C<$fatal> true.
122
123When on_connect is supplied, connect error are not fatal and AnyEvent::DBI
124will not C<die>. You still cannot, however, use the $dbh object you
125received from C<new> to make requests.
126
127=item fork_template => $AnyEvent::Fork-object
128
129C<AnyEvent::DBI> uses C<< AnyEvent::Fork->new >> to create the database
130slave, which in turn either C<exec>'s a new process (similar to the old
131C<exec_server> constructor argument) or uses a process forked early (see
132L<AnyEvent::Fork::Early>).
133
134With this argument you can provide your own fork template. This can be
135useful if you create a lot of C<AnyEvent::DBI> handles and want to save
136memory (And speed up startup) by not having to load C<AnyEvent::DBI> again
137and again into your child processes:
138
139 my $template = AnyEvent::Fork
140 ->new # create new template
141 ->require ("AnyEvent::DBI::Slave"); # preload AnyEvent::DBI::Slave module
142
143 for (...) {
144 $dbh = new AnyEvent::DBI ...
145 fork_template => $template;
146
147=item timeout => seconds
148
149If you supply a timeout parameter (fractional values are supported), then
150a timer is started any time the DBI handle expects a response from the
151server. This includes connection setup as well as requests made to the
152backend. The timeout spans the duration from the moment the first data
153is written (or queued to be written) until all expected responses are
154returned, but is postponed for "timeout" seconds each time more data is
155returned from the server. If the timer ever goes off then a fatal error is
156generated. If you have an C<on_error> handler installed, then it will be
157called, otherwise your program will die().
158
159When altering your databases with timeouts it is wise to use
160transactions. If you quit due to timeout while performing insert, update
161or schema-altering commands you can end up not knowing if the action was
162submitted to the database, complicating recovery.
163
164Timeout errors are always fatal.
123 165
124=back 166=back
125 167
168Any additional key-value pairs will be rolled into a hash reference
169and passed as the final argument to the C<< DBI->connect (...) >>
170call. For example, to suppress errors on STDERR and send them instead to an
171AnyEvent::Handle you could do:
172
173 $dbh = new AnyEvent::DBI
174 "DBI:mysql:test;mysql_read_default_file=/root/.my.cnf", "", "",
175 PrintError => 0,
176 on_error => sub {
177 $log_handle->push_write ("DBI Error: $@ at $_[1]:$_[2]\n");
178 };
179
126=cut 180=cut
127
128# stupid Storable autoloading, total loss-loss situation
129Storable::thaw Storable::freeze [];
130 181
131sub new { 182sub new {
132 my ($class, $dbi, $user, $pass, %arg) = @_; 183 my ($class, $dbi, $user, $pass, %arg) = @_;
133 184
134 socketpair my $client, my $server, &Socket::AF_UNIX, &Socket::SOCK_STREAM, &Socket::PF_UNSPEC 185 # we use our own socketpair, so we always have a socket
186 # available, even before the forked process exsist.
187 # this is mostly done so this module is compatible
188 # to versions of itself older than 3.0.
189 my ($client, $server) = AnyEvent::Util::portable_socketpair
135 or croak "unable to create dbi communicaiton pipe: $!"; 190 or croak "unable to create AnyEvent::DBI communications pipe: $!";
191
192 AnyEvent::fh_unblock $client;
193
194 my $fork = delete $arg{fork_template};
195
196 my %dbi_args = %arg;
197 delete @dbi_args{qw(on_connect on_error timeout fork_template exec_server)};
136 198
137 my $self = bless \%arg, $class; 199 my $self = bless \%arg, $class;
138 200
139 $self->{fh} = $client; 201 $self->{fh} = $client;
140
141 Scalar::Util::weaken (my $wself = $self);
142
143 AnyEvent::Util::fh_nonblocking $client, 1;
144 202
145 my $rbuf; 203 my $rbuf;
146 my @caller = (caller)[1,2]; # the "default" caller 204 my @caller = (caller)[1,2]; # the "default" caller
147 205
148 $self->{rw} = AnyEvent->io (fh => $client, poll => "r", cb => sub { 206 $fork = $fork ? $fork->fork : AnyEvent::Fork->new
149 my $len = sysread $client, $rbuf, 65536, length $rbuf; 207 or croak "fork: $!";
150 208
209 $fork->require ("AnyEvent::DBI::Slave");
210 $fork->send_arg ($VERSION);
211 $fork->send_fh ($server);
212
213 # we don't rely on the callback, because we use our own
214 # socketpair, for better or worse.
215 $fork->run ("AnyEvent::DBI::Slave::serve", sub { });
216
217 {
218 Convert::Scalar::weaken (my $self = $self);
219
220 my $cbor = new CBOR::XS;
221
222 $self->{rw} = AE::io $client, 0, sub {
223 my $len = Convert::Scalar::extend_read $client, $rbuf, 65536;
224
151 if ($len > 0) { 225 if ($len > 0) {
226 # we received data, so reset the timer
227 $self->{last_activity} = AE::now;
152 228
153 while () { 229 for my $res ($cbor->incr_parse_multiple ($rbuf)) {
154 my $len = unpack "L", $rbuf; 230 last unless $self;
155 231
156 # full request available?
157 last unless $len && $len + 4 <= length $rbuf;
158
159 my $res = Storable::thaw substr $rbuf, 4;
160 substr $rbuf, 0, $len + 4, ""; # remove length + request
161
162 my $req = shift @{ $wself->{queue} }; 232 my $req = shift @{ $self->{queue} };
163 233
164 if (defined $res->[0]) { 234 if (defined $res->[0]) {
235 $res->[0] = $self;
165 $req->[0](@$res); 236 $req->[0](@$res);
237 } else {
238 my $cb = shift @$req;
239 local $@ = $res->[1];
240 $cb->($self);
241 $self->_error ($res->[1], @$req, $res->[2]) # error, request record, is_fatal
242 if $self; # cb() could have deleted it
243 }
244
245 # no more queued requests, so become idle
246 if ($self && !@{ $self->{queue} }) {
247 undef $self->{last_activity};
248 $self->{tw_cb}->();
249 }
250 }
251
252 } elsif (defined $len) {
253 # todo, caller?
254 $self->_error ("unexpected eof", @caller, 1);
255 } elsif ($! != Errno::EAGAIN) {
256 # todo, caller?
257 $self->_error ("read error: $!", @caller, 1);
258 }
259 };
260
261 $self->{tw_cb} = sub {
262 if ($self->{timeout} && $self->{last_activity}) {
263 if (AE::now > $self->{last_activity} + $self->{timeout}) {
264 # we did time out
265 my $req = $self->{queue}[0];
266 $self->_error (timeout => $req->[1], $req->[2], 1); # timeouts are always fatal
166 } else { 267 } else {
167 my $cb = shift @$req; 268 # we need to re-set the timeout watcher
168 $wself->_error ($res->[1], @$req); 269 $self->{tw} = AE::timer
270 $self->{last_activity} + $self->{timeout} - AE::now,
271 0,
272 $self->{tw_cb},
169 $cb->[0](); 273 ;
170 } 274 }
275 } else {
276 # no timeout check wanted, or idle
277 undef $self->{tw};
171 } 278 }
172
173 } elsif (defined $len) {
174 $wself->_error ("unexpected eof", @caller, 1);
175 } else {
176 $wself->_error ("read error: $!", @caller, 1);
177 } 279 };
280
281 $self->{ww_cb} = sub {
282 $self->{last_activity} = AE::now;
283
284 my $len = syswrite $client, $self->{wbuf}
285 or return delete $self->{ww};
286
287 substr $self->{wbuf}, 0, $len, "";
288 };
289 }
290
291 $self->_req (
292 sub {
293 return unless $self;
294 $self->{child_pid} = $_[1];
295 },
296 (caller)[1,2],
297 "req_pid"
178 }); 298 );
179 299
180 my $pid = fork; 300 $self->_req (
181 301 sub {
182 if ($pid) { 302 return unless $self;
183 # parent 303 &{ $self->{on_connect} } if $self->{on_connect};
184 close $server; 304 },
185 305 (caller)[1,2],
186 } elsif (defined $pid) { 306 req_open => $dbi, $user, $pass, %dbi_args
187 # child 307 );
188 close $client;
189 @_ = $server;
190 goto &serve;
191
192 } else {
193 croak "fork: $!";
194 }
195
196 $self->_req (sub { }, (caller)[1,2], 1, req_open => $dbi, $user, $pass);
197 308
198 $self 309 $self
310}
311
312sub _server_pid {
313 shift->{child_pid}
314}
315
316sub kill_child {
317 my $self = shift;
318
319 if (my $pid = delete $self->{child_pid}) {
320 # kill and reap process
321 my $kid_watcher; $kid_watcher = AE::child $pid, sub {
322 undef $kid_watcher;
323 };
324 kill TERM => $pid;
325 }
326
327 delete $self->{rw};
328 delete $self->{ww};
329 delete $self->{tw};
330 close delete $self->{fh};
331}
332
333sub DESTROY {
334 shift->kill_child;
199} 335}
200 336
201sub _error { 337sub _error {
202 my ($self, $error, $filename, $line, $fatal) = @_; 338 my ($self, $error, $filename, $line, $fatal) = @_;
203 339
340 if ($fatal) {
341 delete $self->{tw};
204 delete $self->{rw}; 342 delete $self->{rw};
205 delete $self->{ww}; 343 delete $self->{ww};
206 delete $self->{fh}; 344 delete $self->{fh};
207 345
346 # for fatal errors call all enqueued callbacks with error
347 while (my $req = shift @{$self->{queue}}) {
348 local $@ = $error;
349 $req->[0]->($self);
350 }
351 $self->kill_child;
352 }
353
208 $@ = $error; 354 local $@ = $error;
209 355
356 if ($self->{on_error}) {
210 $self->{on_error}($self, $filename, $line, $fatal) 357 $self->{on_error}($self, $filename, $line, $fatal)
211 if $self->{on_error}; 358 } else {
212
213 die "$error at $filename, line $line\n" 359 die "$error at $filename, line $line\n";
214 if $fatal; 360 }
361}
362
363=item $dbh->on_error ($cb->($dbh, $filename, $line, $fatal))
364
365Sets (or clears, with C<undef>) the C<on_error> handler.
366
367=cut
368
369sub on_error {
370 $_[0]{on_error} = $_[1];
371}
372
373=item $dbh->timeout ($seconds)
374
375Sets (or clears, with C<undef>) the database timeout. Useful to extend the
376timeout when you are about to make a really long query.
377
378=cut
379
380sub timeout {
381 my ($self, $timeout) = @_;
382
383 $self->{timeout} = $timeout;
384
385 # reschedule timer if one was running
386 $self->{tw_cb}->();
215} 387}
216 388
217sub _req { 389sub _req {
218 warn "<req(@_>\n";#d#
219 my ($self, $cb, $filename, $line, $fatal) = splice @_, 0, 5, (); 390 my ($self, $cb, $filename, $line) = splice @_, 0, 4, ();
220 391
392 unless ($self->{fh}) {
393 local $@ = my $err = 'no database connection';
394 $cb->($self);
395 $self->_error ($err, $filename, $line, 1);
396 return;
397 }
398
221 push @{ $self->{queue} }, [$cb, $filename, $line, $fatal]; 399 push @{ $self->{queue} }, [$cb, $filename, $line];
222 400
223 $self->{wbuf} .= pack "L/a*", Storable::freeze \@_; 401 # re-start timeout if necessary
402 if ($self->{timeout} && !$self->{tw}) {
403 $self->{last_activity} = AE::now;
404 $self->{tw_cb}->();
405 }
406
407 $self->{wbuf} .= CBOR::XS::encode_cbor \@_;
224 408
225 unless ($self->{ww}) { 409 unless ($self->{ww}) {
226 my $len = syswrite $self->{fh}, $self->{wbuf}; 410 my $len = syswrite $self->{fh}, $self->{wbuf};
227 substr $self->{wbuf}, 0, $len, ""; 411 substr $self->{wbuf}, 0, $len, "";
228 412
229 #TODO, ww_cb
230 # still any left? then install a write watcher 413 # still any left? then install a write watcher
231 $self->{ww} = AnyEvent->io (fh => $self->{fh}, poll => "w", cb => $self->{ww_cb}) 414 $self->{ww} = AE::io $self->{fh}, 1, $self->{ww_cb}
232 if length $self->{wbuf}; 415 if length $self->{wbuf};
233 } 416 }
234} 417}
235 418
419=item $dbh->attr ($attr_name[, $attr_value], $cb->($dbh, $new_value))
420
421An accessor for the database handle attributes, such as C<AutoCommit>,
422C<RaiseError>, C<PrintError> and so on. If you provide an C<$attr_value>
423(which might be C<undef>), then the given attribute will be set to that
424value.
425
426The callback will be passed the database handle and the attribute's value
427if successful.
428
429If an error occurs and the C<on_error> callback returns, then only C<$dbh>
430will be passed and C<$@> contains the error message.
431
236=item $dbh->exec ("statement", @args, $cb->($rows, %extra)) 432=item $dbh->exec ("statement", @args, $cb->($dbh, \@rows, $rv))
237 433
238Executes the given SQL statement with placeholders replaced by 434Executes the given SQL statement with placeholders replaced by
239C<@args>. The statement will be prepared and cached on the 435C<@args>. The statement will be prepared and cached on the server side, so
240server side, so using placeholders is compulsory. 436using placeholders is extremely important.
241 437
242The callback will be called with the result of C<fetchall_arrayref> as 438The callback will be called with a weakened AnyEvent::DBI object as the
243first argument and possibly a hash reference with additional information. 439first argument and the result of C<fetchall_arrayref> as (or C<undef>
440if the statement wasn't a select statement) as the second argument.
441
442Third argument is the return value from the C<< DBI->execute >> method
443call.
444
445If an error occurs and the C<on_error> callback returns, then only C<$dbh>
446will be passed and C<$@> contains the error message.
447
448=item $dbh->stattr ($attr_name, $cb->($dbh, $value))
449
450An accessor for the statement attributes of the most recently executed
451statement, such as C<NAME> or C<TYPE>.
452
453The callback will be passed the database handle and the attribute's value
454if successful.
455
456If an error occurs and the C<on_error> callback returns, then only C<$dbh>
457will be passed and C<$@> contains the error message.
458
459=item $dbh->begin_work ($cb->($dbh[, $rc]))
460
461=item $dbh->commit ($cb->($dbh[, $rc]))
462
463=item $dbh->rollback ($cb->($dbh[, $rc]))
464
465The begin_work, commit, and rollback methods expose the equivalent
466transaction control method of the DBI driver. On success, C<$rc> is true.
467
468If an error occurs and the C<on_error> callback returns, then only C<$dbh>
469will be passed and C<$@> contains the error message.
470
471=item $dbh->func ('string_which_yields_args_when_evaled', $func_name, $cb->($dbh, $rc, $dbi_err, $dbi_errstr))
472
473This gives access to database driver private methods. Because they
474are not standard you cannot always depend on the value of C<$rc> or
475C<$dbi_err>. Check the documentation for your specific driver/function
476combination to see what it returns.
477
478Note that the first argument will be eval'ed to produce the argument list to
479the func() method. This must be done because the serialization protocol
480between the AnyEvent::DBI server process and your program does not support the
481passage of closures.
482
483Here's an example to extend the query language in SQLite so it supports an
484intstr() function:
485
486 $cv = AnyEvent->condvar;
487 $dbh->func (
488 q{
489 instr => 2, sub {
490 my ($string, $search) = @_;
491 return index $string, $search;
492 },
493 },
494 create_function => sub {
495 return $cv->send ($@)
496 unless $#_;
497 $cv->send (undef, @_[1,2,3]);
498 }
499 );
500
501 my ($err,$rc,$errcode,$errstr) = $cv->recv;
502
503 die $err if defined $err;
504 die "EVAL failed: $errstr"
505 if $errcode;
506
507 # otherwise, we can ignore $rc and $errcode for this particular func
244 508
245=cut 509=cut
246 510
247sub exec { 511for my $cmd_name (qw(attr exec stattr begin_work commit rollback func)) {
512 eval 'sub ' . $cmd_name . '{
248 my $cb = pop; 513 my $cb = pop;
249 splice @_, 1, 0, $cb, (caller)[1,2], 0, "exec"; 514 splice @_, 1, 0, $cb, (caller)[1,2], "req_' . $cmd_name . '";
250 515 &_req
251 goto &_req; 516 }';
252} 517}
253 518
254=back 519=back
255 520
256=head1 SEE ALSO 521=head1 SEE ALSO
257 522
258L<AnyEvent>, L<DBI>. 523L<AnyEvent>, L<DBI>, L<Coro::Mysql>.
259 524
260=head1 AUTHOR 525=head1 AUTHOR AND CONTACT
261 526
262 Marc Lehmann <schmorp@schmorp.de> 527 Marc Lehmann <schmorp@schmorp.de> (current maintainer)
263 http://home.schmorp.de/ 528 http://home.schmorp.de/
529
530 Adam Rosenstein <adam@redcondor.com>
531 http://www.redcondor.com/
264 532
265=cut 533=cut
266 534
2671 5351
268

Diff Legend

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