[ViewVC] Diff of: cvs/PApp-SQL/SQL.pm

Comparing PApp-SQL/SQL.pm (file contents):
Revision 1.6 by root, Sun Jan 7 02:53:53 2001 UTC vs.
Revision 1.39 by root, Sun Jun 21 03:30:00 2009 UTC

…		…
1	=head1 NAME	1	=head1 NAME
2		2
3	PApp::SQL - absolutely easy yet fast and powerful sql access	3	PApp::SQL - absolutely easy yet fast and powerful sql access.
4		4
5	=head1 SYNOPSIS	5	=head1 SYNOPSIS
6		6
7	use PApp::SQL;	7	use PApp::SQL;
8	# to be written	8
		9	my $st = sql_exec $DBH, "select ... where a = ?", $a;
		10
		11	local $DBH = <database handle>;
		12	my $st = sql_exec \my($bind_a, $bind_b), "select a,b ...";
		13	my $id = sql_insertid
		14	sql_exec "insert into ... values (?, ?)", $v1, $v2;
		15	my $a = sql_fetch "select a from ...";
		16	sql_fetch \my($a, $b), "select a,b ...";
		17
		18	sql_exists "table where name like 'a%'"
		19	or die "a* required but not existent";
		20
		21	my $db = new PApp::SQL::Database "", "DBI:mysql:test", "user", "pass";
		22	local $PApp::SQL::DBH = $db->checked_dbh; # does 'ping'
		23
		24	sql_exec $db->dbh, "select ...";
9		25
10	=head1 DESCRIPTION	26	=head1 DESCRIPTION
11		27
12	This module provides you with easy-to-use functions to execute sql	28	This module provides you with easy-to-use functions to execute sql
13	commands (using DBI). Despite being easy to use, they are also quite	29	commands (using DBI). Despite being easy to use, they are also quite
14	efficient and allow you to write faster programs in less lines of code.	30	efficient and allow you to write faster programs in less lines of code. It
		31	should work with anything from perl-5.004_01 onwards, but I only support
		32	5.005+. UTF8 handling (the C<sql_u*> family of functions) will only be
		33	effective with perl version 5.006 and beyond.
15		34
16	=over 4	35	If the descriptions here seem terse or if you always wanted to know
		36	what PApp is then have a look at the PApp module which uses this module
		37	extensively but also provides you with a lot more gimmicks to play around
		38	with to help you create cool applications ;)
17		39
18	=cut	40	=cut
19		41
20	package PApp::SQL;	42	package PApp::SQL;
21		43
		44	use Carp ();
22	use DBI;	45	use DBI ();
23
24	#use PApp::Exception; # not yet used
25		46
26	BEGIN {	47	BEGIN {
27	use base Exporter;	48	use base qw(Exporter DynaLoader);
28		49
29	$VERSION = 0.11;	50	$VERSION = '1.05';
30	@EXPORT = qw(	51	@EXPORT = qw(
31	sql_exec sql_fetch sql_fetchall sql_exists sql_insertid $sql_exec	52	sql_exec sql_fetch sql_fetchall sql_exists sql_insertid $sql_exec
		53	sql_uexec sql_ufetch sql_ufetchall sql_uexists
32	);	54	);
33	@EXPORT_OK = qw(	55	@EXPORT_OK = qw(
34	connect_cached	56	connect_cached
35	);	57	);
36		58
37	require XSLoader;	59	bootstrap PApp::SQL $VERSION;
38	XSLoader::load PApp::SQL, $VERSION;
39	}	60	}
40		61
41	our $sql_exec; # last result of sql_exec's execute call	62	our $sql_exec; # last result of sql_exec's execute call
42	our $DBH; # the default database handle	63	our $DBH; # the default database handle
43	our $database; # the current SQL::Database object, if applicable	64	our $Database; # the current SQL::Database object, if applicable
44		65
45	our %dbcache;	66	our %dbcache;
		67
		68	=head2 Global Variables
		69
		70	=over 4
		71
		72	=item $sql_exec
		73
		74	Since the C<sql_exec> family of functions return a statement handle there
		75	must be another way to test the return value of the C<execute> call. This
		76	global variable contains the result of the most recent call to C<execute>
		77	done by this module.
		78
		79	=item $PApp::SQL::DBH
		80
		81	The default database handle used by this module if no C<$DBH> was
		82	specified as argument. See C<sql_exec> for a discussion.
		83
		84	=item $PApp::SQL::Database
		85
		86	The current default C<PApp::SQL::Database>-object. Future versions might
		87	automatically fall back on this database and create database handles from
		88	it if neccessary. At the moment this is not used by this module but might
		89	be nice as a placeholder for the database object that corresponds to
		90	$PApp::SQL::DBH.
		91
		92	=back
		93
		94	=head2 Functions
		95
		96	=over 4
46		97
47	=item $dbh = connect_cached $id, $dsn, $user, $pass, $flags, $connect	98	=item $dbh = connect_cached $id, $dsn, $user, $pass, $flags, $connect
48		99
49	(not exported by by default)	100	(not exported by by default)
50		101
60	__LINE__ work fine as well).	111	__LINE__ work fine as well).
61		112
62	The reason C<$id> is necessary is that you might specify special connect	113	The reason C<$id> is necessary is that you might specify special connect
63	arguments or special flags, or you might want to configure your $DBH	114	arguments or special flags, or you might want to configure your $DBH
64	differently than maybe other applications requesting the same database	115	differently than maybe other applications requesting the same database
65	connection. If none of this is becessary for your application you can	116	connection. If none of this is necessary for your application you can
66	leave $id empty (i.e. "").	117	leave C<$id> empty (i.e. "").
67		118
68	If specified, C<$connect> is a callback (e.g. a coderef) that will be	119	If specified, C<$connect> is a callback (e.g. a coderef) that will be
69	called each time a new connection is being established, with the new	120	called each time a new connection is being established, with the new
70	C<$dbh> as first argument.	121	C<$dbh> as first argument.
71		122
72	Examples:	123	Examples:
73		124
74	# try your luck opening the papp database without access info	125	# try your luck opening the papp database without access info
75	$dbh = connect_cached __FILE__, "DBI:mysql:papp";	126	$dbh = connect_cached __FILE__, "DBI:mysql:papp";
		127
		128	Mysql-specific behaviour: The default setting of
		129	C<mysql_client_found_rows> is TRUE, you can overwrite this, though.
76		130
77	=cut	131	=cut
78		132
79	sub connect_cached {	133	sub connect_cached {
80	my ($id, $dsn, $user, $pass, $flags, $connect) = @_;	134	my ($id, $dsn, $user, $pass, $flags, $connect) = @_;
81	# the following line is duplicated in PApp::SQL::Database::new	135	# the following line is duplicated in PApp::SQL::Database::new
82	$id = "$id\0$dsn\0$user\0$pass";	136	$id = "$id\0$dsn\0$user\0$pass";
83	unless ($dbcache{$id} && $dbcache{$id}->ping) {	137	unless ($dbcache{$id} && $dbcache{$id}->ping) {
84	#warn "connecting to ($dsn\|$user\|$pass\|$flags)\n";#d#
85	# first, nuke our statement cache (sooory ;)	138	# first, nuke our statement cache (sooory ;)
86	cachesize cachesize 0;	139	cachesize cachesize 0;
		140
		141	# then make mysql behave more standardly by default
		142	$dsn =~ /^[Dd][Bb][Ii]:mysql:/
		143	and $dsn !~ /;mysql_client_found_rows/
		144	and $dsn .= ";mysql_client_found_rows=1";
		145
87	# then connect anew	146	# then connect anew
88	$dbcache{$id} =	147	$dbcache{$id} =
89	eval { DBI->connect($dsn, $user, $pass, $flags) }	148	eval { DBI->connect($dsn, $user, $pass, $flags) }
90	\|\| eval { DBI->connect($dsn, $user, $pass, $flags) }	149	\|\| eval { DBI->connect($dsn, $user, $pass, $flags) }
91	\|\| die "unable to connect to database $dsn: $DBI::errstr\n";	150	\|\| Carp::croak "unable to connect to database $dsn: $DBI::errstr\n";
92	$connect->($dbcache{$id}) if $connect;	151	$connect->($dbcache{$id}) if $connect;
93	}	152	}
94	$dbcache{$id};	153	$dbcache{$id};
95	}	154	}
96		155
97	=item $sth = sql_exec [dbh,] [bind-vals...,] "sql-statement", [arguments...]	156	=item $sth = sql_exec [dbh,] [bind-vals...,] "sql-statement", [arguments...]
		157
		158	=item $sth = sql_uexec <see sql_exec>
98		159
99	C<sql_exec> is the most important and most-used function in this module.	160	C<sql_exec> is the most important and most-used function in this module.
100		161
101	Runs the given sql command with the given parameters and returns the	162	Runs the given sql command with the given parameters and returns the
102	statement handle. The command and the statement handle will be cached	163	statement handle. The command and the statement handle will be cached
103	(with the database handle and the sql string as key), so prepare will be	164	(with the database handle and the sql string as key), so prepare will be
104	called only once for each distinct sql call (please keep in mind that the	165	called only once for each distinct sql call (please keep in mind that the
105	returned statement will always be the same, so, if you call C<sql_exec>	166	returned statement will always be the same, so, if you call C<sql_exec>
106	with the same dbh and sql-statement twice (e.g. in a subroutine you	167	with the same dbh and sql-statement twice (e.g. in a subroutine you
107	called), the statement handle for the first call mustn't be used.	168	called), the statement handle for the first call mustn't not be in use
		169	anymore, as the subsequent call will re-use the handle.
108		170
109	The database handle (the first argument) is optional. If it is missing,	171	The database handle (the first argument) is optional. If it is missing,
110	C<sql_exec> first tries to use the variable C<$DBH> in the current (=	172	it tries to use database handle in C<$PApp::SQL::DBH>, which you can set
111	calling) package and, if that fails, it tries to use database handle in	173	before calling these functions. NOTICE: future and former versions of
112	C<$PApp::SQL::DBH>, which you can set before calling these functions.	174	PApp::SQL might also look up the global variable C<$DBH> in the callers
		175	package.
		176
		177	=begin comment
		178
		179	If it is missing, C<sql_exec> first tries to use the variable C<$DBH>
		180	in the current (= calling) package and, if that fails, it tries to use
		181	database handle in C<$PApp::SQL::DBH>, which you can set before calling
		182	these functions.
		183
		184	=end comment
113		185
114	The actual return value from the C<$sth->execute> call is stored in the	186	The actual return value from the C<$sth->execute> call is stored in the
115	package-global (and exported) variable C<$sql_exec>.	187	package-global (and exported) variable C<$sql_exec>.
116		188
117	If any error occurs C<sql_exec> will throw an exception.	189	If any error occurs C<sql_exec> will throw an exception.
		190
		191	C<sql_uexec> is similar to C<sql_exec> but upgrades all input arguments to
		192	UTF-8 before calling the C<execute> method.
118		193
119	Examples:	194	Examples:
120		195
121	# easy one	196	# easy one
122	my $st = sql_exec "select name, id from table where id = ?", $id;	197	my $st = sql_exec "select name, id from table where id = ?", $id;
…		…
132	sql_exec $dbh, "update file set name = ?", "oops.txt";	207	sql_exec $dbh, "update file set name = ?", "oops.txt";
133		208
134		209
135	=item sql_fetch <see sql_exec>	210	=item sql_fetch <see sql_exec>
136		211
		212	=item sql_ufetch <see sql_uexec>
		213
137	Execute a sql-statement and fetch the first row of results. Depending on	214	Execute an sql-statement and fetch the first row of results. Depending on
138	the caller context the row will be returned as a list (array context), or	215	the caller context the row will be returned as a list (array context), or
139	just the first columns. In table form:	216	just the first columns. In table form:
140		217
141	CONTEXT RESULT	218	CONTEXT RESULT
142	void ()	219	void ()
…		…
153		230
154	my($name, $amount) = sql_fetch "select ...", args...	231	my($name, $amount) = sql_fetch "select ...", args...
155		232
156	... and it's still quite fast unless you fetch large amounts of data.	233	... and it's still quite fast unless you fetch large amounts of data.
157		234
		235	C<sql_ufetch> is similar to C<sql_fetch> but upgrades all input values to
		236	UTF-8 and forces all result values to UTF-8 (this does I<not> include result
		237	parameters, only return values. Using bind variables in conjunction with
		238	sql_u* functions might result in undefined behaviour - we use UTF-8 on
		239	bind-variables at execution time and it seems to work on DBD::mysql as it
		240	ignores the UTF-8 bit completely. Which just means that that DBD-driver is
		241	broken).
		242
158	=item sql_fetchall <see sql_exec>	243	=item sql_fetchall <see sql_exec>
		244
		245	=item sql_ufetchall <see sql_uexec>
159		246
160	Similarly to C<sql_fetch>, but all result rows will be fetched (this is	247	Similarly to C<sql_fetch>, but all result rows will be fetched (this is
161	of course inefficient for large results!). The context is ignored (only	248	of course inefficient for large results!). The context is ignored (only
162	list context makes sense), but the result still depends on the number of	249	list context makes sense), but the result still depends on the number of
163	columns in the result:	250	columns in the result:
…		…
175		262
176	for (sql_fetchall "select name, age, place from user") {	263	for (sql_fetchall "select name, age, place from user") {
177	my ($name, $age, $place) = @$_;	264	my ($name, $age, $place) = @$_;
178	}	265	}
179		266
		267	C<sql_ufetchall> is similar to C<sql_fetchall> but upgrades all input
		268	values to UTF-8 and forces all result values to UTF-8 (see the caveats in
		269	the description of C<sql_ufetch>, though).
		270
180	=item sql_exists "<table> where ...", args...	271	=item sql_exists "<table_references> where <where_condition>...", args...
		272
		273	=item sql_uexists <see sql_exists>
181		274
182	Check wether the result of the sql-statement "select xxx from	275	Check wether the result of the sql-statement "select xxx from
183	$first_argument" would be empty or not (that is, imagine the string	276	$first_argument" would be empty or not (that is, imagine the string
184	"select from" were prepended to your statement (it isn't)). Should work	277	"select * from" were prepended to your statement (it isn't)). Should work
185	with every database but can be quite slow, except on mysql, where this	278	with every database but can be quite slow, except on mysql, where this
186	should be quite fast.	279	should be quite fast.
		280
		281	C<sql_uexists> is similar to C<sql_exists> but upgrades all parameters to
		282	UTF-8.
187		283
188	Examples:	284	Examples:
189		285
190	print "user 7 exists!\n"	286	print "user 7 exists!\n"
191	if sql_exists "user where id = ?", 7;	287	if sql_exists "user where id = ?", 7;
…		…
195		291
196	=cut	292	=cut
197		293
198	=item $lastid = sql_insertid $sth	294	=item $lastid = sql_insertid $sth
199		295
200	Returns the last automatically created key value (e.g. for mysql	296	Returns the last automatically created key value. It must be executed
201	AUTO_INCREMENT or sybase IDENTITY fields). It must be executed directly
202	after executing the insert statement that created it.	297	directly after executing the insert statement that created it. This is
		298	what is actually returned for various databases. If your database is
		299	missing, please send me an e-mail on how to implement this ;)
		300
		301	mysql: first C<AUTO_INCREMENT> column set to NULL
		302	postgres: C<oid> column (is there a way to get the last SERIAL?)
		303	sybase: C<IDENTITY> column of the last insert (slow)
		304	informix: C<SERIAL> or C<SERIAL8> column of the last insert
		305	sqlite: C<last_insert_rowid()>
		306
		307	Except for sybase, this does not require a server access.
203		308
204	=cut	309	=cut
205		310
206	sub sql_insertid($) {	311	sub sql_insertid($) {
207	my $sth = shift or die "sql_insertid requires a statement handle";	312	my $sth = shift or Carp::croak "sql_insertid requires a statement handle";
208	my $dbh = $sth->{Database};	313	my $dbh = $sth->{Database};
209	my $driver = $dbh->{Driver}{Name};	314	my $driver = $dbh->{Driver}{Name};
210		315
211	$driver eq "mysql" and return $sth->{mysql_insertid};	316	$driver eq "mysql" and return $sth->{mysql_insertid};
		317	$driver eq "Pg" and return $sth->{pg_oid_status};
212	$driver eq "Sybase" and return sql_fetch($dbh, 'SELECT @@IDENTITY');	318	$driver eq "Sybase" and return sql_fetch ($dbh, 'SELECT @@IDENTITY');
213	$driver eq "Informix" and return $sth->{ix_sqlerrd}[1];	319	$driver eq "Informix" and return $sth->{ix_sqlerrd}[1];
		320	$driver eq "SQLite" and return sql_fetch ($dbh, 'SELECT last_insert_rowid ()');
214		321
215	die "sql_insertid does not spport the dbd driver '$driver', please see PApp::SQL::sql_insertid";	322	Carp::croak "sql_insertid does not support the dbd driver '$driver', at";
216	}	323	}
217		324
218	=item [old-size] = cachesize [new-size]	325	=item [old-size] = cachesize [new-size]
219		326
220	Returns (and possibly changes) the LRU cache size used by C<sql_exec>. The	327	Returns (and possibly changes) the LRU cache size used by C<sql_exec>. The
221	default is somewhere around 50 (= the 50 last recently used statements	328	default is somewhere around 50 (= the 50 last recently used statements
222	will be cached). It shouldn't be too large, since a simple linear listed	329	will be cached). It shouldn't be too large, since a simple linear list
223	is used for the cache at the moment (which, for small (<100) cache sizes	330	is used for the cache at the moment (which, for small (<100) cache sizes
224	is actually quite fast).	331	is actually quite fast).
225		332
226	The function always returns the cache size in effect I<before> the call,	333	The function always returns the cache size in effect I<before> the call,
227	so, to nuke the cache (for example, when a database connection has died	334	so, to nuke the cache (for example, when a database connection has died
…		…
232		339
233	=cut	340	=cut
234		341
235	=item reinitialize [not exported]	342	=item reinitialize [not exported]
236		343
237	Clears any internal caches (statement cache, database handle cache).	344	Clears any internal caches (statement cache, database handle
		345	cache). Should be called after C<fork> and other accidents that invalidate
		346	database handles.
238		347
239	=cut	348	=cut
240		349
241	sub reinitialize {	350	sub reinitialize {
242	cachesize cachesize 0;	351	cachesize cachesize 0;
243	for (values %dbcache) {	352	for (values %dbcache) {
244	eval { $_->disconnect };	353	eval { $_->{InactiveDestroy} = 1 };
245	}	354	}
246	undef %dbcache;	355	undef %dbcache;
247	}	356	}
248		357
249	=back	358	=back
250		359
251	=cut	360	=cut
252		361
		362	reinitialize;
		363
253	package PApp::SQL::Database;	364	package PApp::SQL::Database;
254		365
255	=head2 THE DATABASE CLASS	366	=head2 The Database Class
256		367
257	Again (sigh) the problem of persistency. What do you do when you have to serialize on object	368	Again (sigh) the problem of persistency. What do you do when you have
258	that contains (or should contain) a database handle? Short answer: you don't. Long answer:	369	to serialize on object that contains (or should contain) a database
		370	handle? Short answer: you don't. Long answer: you can embed the necessary
259	you can embed the necessary information to recreate the dbh when needed.	371	information to recreate the dbh when needed.
260		372
261	The C<PApp::SQL::Database> class does that, in a relatively efficient	373	The C<PApp::SQL::Database> class does that, in a relatively efficient
262	fashion: the overhead is currently a single method call per access (you	374	fashion: the overhead is currently a single method call per access (you
263	can cache the real dbh if you want).	375	can cache the real dbh if you want).
264		376
…		…
297		409
298	sub checked_dbh($) {	410	sub checked_dbh($) {
299	my $dbh = $dbcache{$_[0][0]};	411	my $dbh = $dbcache{$_[0][0]};
300	$dbh && $dbh->ping	412	$dbh && $dbh->ping
301	? $dbh	413	? $dbh
302	: PApp::SQL::connect_cached((split /\x00/, $_[0][0]), $_[0][1], $_[0][2]);	414	: PApp::SQL::connect_cached((split /\x00/, $_[0][0], 4), $_[0][1], $_[0][2]);
303	}	415	}
304		416
305	=item $db->dsn	417	=item $db->dsn
306		418
307	Return the DSN (L<DBI>) fo the database object (e.g. for error messages).	419	Return the DSN (L<DBI>) fo the database object (e.g. for error messages).
		420
		421	=item $db->login
		422
		423	Return the login name.
		424
		425	=item $db->password
		426
		427	Return the password (emphasizing the fact that the password is stored plaintext ;)
308		428
309	=cut	429	=cut
310		430
311	sub dsn($) {	431	sub dsn($) {
312	my $self = shift;	432	my $self = shift;
313	$self->[1][1];	433	(split /\x00/, $self->[0])[1];
		434	}
		435
		436	sub login($) {
		437	my $self = shift;
		438	(split /\x00/, $self->[0])[2];
		439	}
		440
		441	sub password($) {
		442	my $self = shift;
		443	(split /\x00/, $self->[0])[3];
314	}	444	}
315		445
316	=back	446	=back
317		447
318	=cut	448	=cut
319		449
320	reinitialize;
321
322	1;	450	1;
323		451
324	=head1 BUGS
325
326	As of this writing, sql_fetch and sql_fetchall are not very well tested
327	(they were just re-written in C).
328
329	sql_exists could be faster (it is written very ugly to not change the
330	current package).
331
332	=head1 SEE ALSO	452	=head1 SEE ALSO
333		453
334	L<PApp>.	454	L<PApp>.
335		455
336	=head1 AUTHOR	456	=head1 AUTHOR
337		457
338	Marc Lehmann <pcg@goof.com>	458	Marc Lehmann <schmorp@schmorp.de>
339	http://www.goof.com/pcg/marc/	459	http://home.schmorp.de/
340		460
341	=cut	461	=cut
342		462

Diff Legend

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

Comparing PApp-SQL/SQL.pm (file contents): Revision 1.6 by root, Sun Jan 7 02:53:53 2001 UTC vs. Revision 1.39 by root, Sun Jun 21 03:30:00 2009 UTC

Diff Legend

Comparing PApp-SQL/SQL.pm (file contents):
Revision 1.6 by root, Sun Jan 7 02:53:53 2001 UTC vs.
Revision 1.39 by root, Sun Jun 21 03:30:00 2009 UTC