[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.43 by root, Mon Mar 4 06:25:32 2019 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 fewer lines of
		31	code. It should work with anything from perl-5.004_01 onwards, but I only
		32	support 5.005+. UTF8 handling (the C<sql_u*> family of functions) will
		33	only be 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 = '2.002';
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	}
		61
		62	boot2 DBI::SQL_VARCHAR, DBI::SQL_INTEGER, DBI::SQL_DOUBLE;
40		63
41	our $sql_exec; # last result of sql_exec's execute call	64	our $sql_exec; # last result of sql_exec's execute call
42	our $DBH; # the default database handle	65	our $DBH; # the default database handle
43	our $database; # the current SQL::Database object, if applicable	66	our $Database; # the current SQL::Database object, if applicable
44		67
45	our %dbcache;	68	our %dbcache;
		69
		70	=head2 Global Variables
		71
		72	=over 4
		73
		74	=item $sql_exec
		75
		76	Since the C<sql_exec> family of functions return a statement handle there
		77	must be another way to test the return value of the C<execute> call. This
		78	global variable contains the result of the most recent call to C<execute>
		79	done by this module.
		80
		81	=item $PApp::SQL::DBH
		82
		83	The default database handle used by this module if no C<$DBH> was
		84	specified as argument. See C<sql_exec> for a discussion.
		85
		86	=item $PApp::SQL::Database
		87
		88	The current default C<PApp::SQL::Database>-object. Future versions might
		89	automatically fall back on this database and create database handles from
		90	it if neccessary. At the moment this is not used by this module but might
		91	be nice as a placeholder for the database object that corresponds to
		92	$PApp::SQL::DBH.
		93
		94	=back
		95
		96	=head2 Functions
		97
		98	=over 4
46		99
47	=item $dbh = connect_cached $id, $dsn, $user, $pass, $flags, $connect	100	=item $dbh = connect_cached $id, $dsn, $user, $pass, $flags, $connect
48		101
49	(not exported by by default)	102	(not exported by by default)
50		103
51	Connect to the database given by C<($dsn,$user,$pass)>, while using the	104	Connect to the database given by C<($dsn,$user,$pass)>, while using the
52	flags from C<$flags>. These are just the same arguments as given to	105	flags from C<$flags>. These are just the same arguments as given to
53	C<DBI->connect>.	106	C<< DBI->connect >>.
54		107
55	The database handle will be cached under the unique id	108	The database handle will be cached under the unique id
56	C<$id\|$dsn\|$user\|$pass>. If the same id is requested later, the	109	C<$id\|$dsn\|$user\|$pass>. If the same id is requested later, the
57	cached handle will be checked (using ping), and the connection will	110	cached handle will be checked (using ping), and the connection will
58	be re-established if necessary (be sure to prefix your application or	111	be re-established if necessary (be sure to prefix your application or
60	__LINE__ work fine as well).	113	__LINE__ work fine as well).
61		114
62	The reason C<$id> is necessary is that you might specify special connect	115	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	116	arguments or special flags, or you might want to configure your $DBH
64	differently than maybe other applications requesting the same database	117	differently than maybe other applications requesting the same database
65	connection. If none of this is becessary for your application you can	118	connection. If none of this is necessary for your application you can
66	leave $id empty (i.e. "").	119	leave C<$id> empty (i.e. "").
67		120
68	If specified, C<$connect> is a callback (e.g. a coderef) that will be	121	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	122	called each time a new connection is being established, with the new
70	C<$dbh> as first argument.	123	C<$dbh> as first argument.
71		124
72	Examples:	125	Examples:
73		126
74	# try your luck opening the papp database without access info	127	# try your luck opening the papp database without access info
75	$dbh = connect_cached __FILE__, "DBI:mysql:papp";	128	$dbh = connect_cached __FILE__, "DBI:mysql:papp";
		129
		130	Mysql-specific behaviour: The default setting of
		131	C<mysql_client_found_rows> is TRUE, you can overwrite this, though.
76		132
77	=cut	133	=cut
78		134
79	sub connect_cached {	135	sub connect_cached {
80	my ($id, $dsn, $user, $pass, $flags, $connect) = @_;	136	my ($id, $dsn, $user, $pass, $flags, $connect) = @_;
81	# the following line is duplicated in PApp::SQL::Database::new	137	# the following line is duplicated in PApp::SQL::Database::new
82	$id = "$id\0$dsn\0$user\0$pass";	138	$id = "$id\0$dsn\0$user\0$pass";
83	unless ($dbcache{$id} && $dbcache{$id}->ping) {	139	unless ($dbcache{$id} && $dbcache{$id}->ping) {
84	#warn "connecting to ($dsn\|$user\|$pass\|$flags)\n";#d#
85	# first, nuke our statement cache (sooory ;)	140	# first, nuke our statement cache (sooory ;)
86	cachesize cachesize 0;	141	cachesize cachesize 0;
		142
		143	# then make mysql behave more standardly by default
		144	$dsn =~ /^[Dd][Bb][Ii]:mysql:/
		145	and $dsn !~ /;mysql_client_found_rows/
		146	and $dsn .= ";mysql_client_found_rows=1";
		147
87	# then connect anew	148	# then connect anew
88	$dbcache{$id} =	149	$dbcache{$id} =
89	eval { DBI->connect($dsn, $user, $pass, $flags) }	150	eval { DBI->connect($dsn, $user, $pass, $flags) }
90	\|\| eval { DBI->connect($dsn, $user, $pass, $flags) }	151	\|\| eval { DBI->connect($dsn, $user, $pass, $flags) }
91	\|\| die "unable to connect to database $dsn: $DBI::errstr\n";	152	\|\| Carp::croak "unable to connect to database $dsn: $DBI::errstr\n";
92	$connect->($dbcache{$id}) if $connect;	153	$connect->($dbcache{$id}) if $connect;
93	}	154	}
94	$dbcache{$id};	155	$dbcache{$id};
95	}	156	}
96		157
97	=item $sth = sql_exec [dbh,] [bind-vals...,] "sql-statement", [arguments...]	158	=item $sth = sql_exec [dbh,] [bind-vals...,] "sql-statement", [arguments...]
		159
		160	=item $sth = sql_uexec <see sql_exec>
98		161
99	C<sql_exec> is the most important and most-used function in this module.	162	C<sql_exec> is the most important and most-used function in this module.
100		163
101	Runs the given sql command with the given parameters and returns the	164	Runs the given sql command with the given parameters and returns the
102	statement handle. The command and the statement handle will be cached	165	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	166	(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	167	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>	168	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	169	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.	170	called), the statement handle for the first call mustn't not be in use
		171	anymore, as the subsequent call will re-use the handle.
108		172
109	The database handle (the first argument) is optional. If it is missing,	173	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 (=	174	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	175	before calling these functions. NOTICE: future and former versions of
112	C<$PApp::SQL::DBH>, which you can set before calling these functions.	176	PApp::SQL might also look up the global variable C<$DBH> in the callers
		177	package.
113		178
		179	=begin comment
		180
		181	If it is missing, C<sql_exec> first tries to use the variable C<$DBH>
		182	in the current (= calling) package and, if that fails, it tries to use
		183	database handle in C<$PApp::SQL::DBH>, which you can set before calling
		184	these functions.
		185
		186	=end comment
		187
114	The actual return value from the C<$sth->execute> call is stored in the	188	The actual return value from the C<< $sth->execute >> call is stored in
115	package-global (and exported) variable C<$sql_exec>.	189	the package-global (and exported) variable C<$sql_exec>.
116		190
117	If any error occurs C<sql_exec> will throw an exception.	191	If any error occurs C<sql_exec> will throw an exception.
		192
		193	C<sql_uexec> is similar to C<sql_exec> but upgrades all input arguments to
		194	UTF-8 before calling the C<execute> method.
118		195
119	Examples:	196	Examples:
120		197
121	# easy one	198	# easy one
122	my $st = sql_exec "select name, id from table where id = ?", $id;	199	my $st = sql_exec "select name, id from table where id = ?", $id;
…		…
132	sql_exec $dbh, "update file set name = ?", "oops.txt";	209	sql_exec $dbh, "update file set name = ?", "oops.txt";
133		210
134		211
135	=item sql_fetch <see sql_exec>	212	=item sql_fetch <see sql_exec>
136		213
		214	=item sql_ufetch <see sql_uexec>
		215
137	Execute a sql-statement and fetch the first row of results. Depending on	216	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	217	the caller context the row will be returned as a list (array context), or
139	just the first columns. In table form:	218	just the first columns. In table form:
140		219
141	CONTEXT RESULT	220	CONTEXT RESULT
142	void ()	221	void ()
…		…
153		232
154	my($name, $amount) = sql_fetch "select ...", args...	233	my($name, $amount) = sql_fetch "select ...", args...
155		234
156	... and it's still quite fast unless you fetch large amounts of data.	235	... and it's still quite fast unless you fetch large amounts of data.
157		236
		237	C<sql_ufetch> is similar to C<sql_fetch> but upgrades all input values to
		238	UTF-8 and forces all result values to UTF-8 (this does I<not> include result
		239	parameters, only return values. Using bind variables in conjunction with
		240	sql_u* functions might result in undefined behaviour - we use UTF-8 on
		241	bind-variables at execution time and it seems to work on DBD::mysql as it
		242	ignores the UTF-8 bit completely. Which just means that that DBD-driver is
		243	broken).
		244
158	=item sql_fetchall <see sql_exec>	245	=item sql_fetchall <see sql_exec>
		246
		247	=item sql_ufetchall <see sql_uexec>
159		248
160	Similarly to C<sql_fetch>, but all result rows will be fetched (this is	249	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	250	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	251	list context makes sense), but the result still depends on the number of
163	columns in the result:	252	columns in the result:
…		…
175		264
176	for (sql_fetchall "select name, age, place from user") {	265	for (sql_fetchall "select name, age, place from user") {
177	my ($name, $age, $place) = @$_;	266	my ($name, $age, $place) = @$_;
178	}	267	}
179		268
		269	C<sql_ufetchall> is similar to C<sql_fetchall> but upgrades all input
		270	values to UTF-8 and forces all result values to UTF-8 (see the caveats in
		271	the description of C<sql_ufetch>, though).
		272
180	=item sql_exists "<table> where ...", args...	273	=item sql_exists "<table_references> where <where_condition>...", args...
		274
		275	=item sql_uexists <see sql_exists>
181		276
182	Check wether the result of the sql-statement "select xxx from	277	Check wether the result of the sql-statement "select xxx from
183	$first_argument" would be empty or not (that is, imagine the string	278	$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	279	"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	280	with every database but can be quite slow, except on mysql, where this
186	should be quite fast.	281	should be quite fast.
		282
		283	C<sql_uexists> is similar to C<sql_exists> but upgrades all parameters to
		284	UTF-8.
187		285
188	Examples:	286	Examples:
189		287
190	print "user 7 exists!\n"	288	print "user 7 exists!\n"
191	if sql_exists "user where id = ?", 7;	289	if sql_exists "user where id = ?", 7;
…		…
195		293
196	=cut	294	=cut
197		295
198	=item $lastid = sql_insertid $sth	296	=item $lastid = sql_insertid $sth
199		297
200	Returns the last automatically created key value (e.g. for mysql	298	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.	299	directly after executing the insert statement that created it. This is
		300	what is actually returned for various databases. If your database is
		301	missing, please send me an e-mail on how to implement this ;)
		302
		303	mariadb: first C<AUTO_INCREMENT> column set to NULL
		304	mysql: first C<AUTO_INCREMENT> column set to NULL
		305	postgres: C<oid> column (is there a way to get the last SERIAL?)
		306	sybase: C<IDENTITY> column of the last insert (slow)
		307	informix: C<SERIAL> or C<SERIAL8> column of the last insert
		308	sqlite: C<last_insert_rowid()>
		309
		310	Except for sybase, this does not require a server access.
203		311
204	=cut	312	=cut
205		313
206	sub sql_insertid($) {	314	sub sql_insertid($) {
207	my $sth = shift or die "sql_insertid requires a statement handle";	315	my $sth = shift or Carp::croak "sql_insertid requires a statement handle";
208	my $dbh = $sth->{Database};	316	my $dbh = $sth->{Database};
209	my $driver = $dbh->{Driver}{Name};	317	my $driver = $dbh->{Driver}{Name};
210		318
		319	$driver eq "MariaDB" and return $sth->{mariadb_insertid};
211	$driver eq "mysql" and return $sth->{mysql_insertid};	320	$driver eq "mysql" and return $sth->{mysql_insertid};
		321	$driver eq "Pg" and return $sth->{pg_oid_status};
212	$driver eq "Sybase" and return sql_fetch($dbh, 'SELECT @@IDENTITY');	322	$driver eq "Sybase" and return sql_fetch ($dbh, 'SELECT @@IDENTITY');
213	$driver eq "Informix" and return $sth->{ix_sqlerrd}[1];	323	$driver eq "Informix" and return $sth->{ix_sqlerrd}[1];
		324	$driver eq "SQLite" and return sql_fetch ($dbh, 'SELECT last_insert_rowid ()');
214		325
215	die "sql_insertid does not spport the dbd driver '$driver', please see PApp::SQL::sql_insertid";	326	$dbh->last_insert_id (undef, undef, undef, undef)
216	}	327	}
217		328
218	=item [old-size] = cachesize [new-size]	329	=item [old-size] = cachesize [new-size]
219		330
220	Returns (and possibly changes) the LRU cache size used by C<sql_exec>. The	331	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	332	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	333	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	334	is used for the cache at the moment (which, for small (<100) cache sizes
224	is actually quite fast).	335	is actually quite fast).
225		336
226	The function always returns the cache size in effect I<before> the call,	337	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	338	so, to nuke the cache (for example, when a database connection has died
…		…
232		343
233	=cut	344	=cut
234		345
235	=item reinitialize [not exported]	346	=item reinitialize [not exported]
236		347
237	Clears any internal caches (statement cache, database handle cache).	348	Clears any internal caches (statement cache, database handle
		349	cache). Should be called after C<fork> and other accidents that invalidate
		350	database handles.
238		351
239	=cut	352	=cut
240		353
241	sub reinitialize {	354	sub reinitialize {
242	cachesize cachesize 0;	355	cachesize cachesize 0;
243	for (values %dbcache) {	356	for (values %dbcache) {
244	eval { $_->disconnect };	357	eval { $_->{InactiveDestroy} = 1 };
245	}	358	}
246	undef %dbcache;	359	undef %dbcache;
247	}	360	}
248		361
249	=back	362	=back
250		363
251	=cut	364	=cut
252		365
		366	reinitialize;
		367
		368	=head2 Type Deduction
		369
		370	Since every database driver seems to deduce parameter types differently,
		371	usually wrongly, and at leats in the case of DBD::mysql, different in
		372	every other release or so, and this can and does lead to data corruption,
		373	this module does type deduction itself.
		374
		375	What does it mean? Simple - sql parameters for placeholders will be
		376	explicitly marked as SQL_VARCHAR, SQL_INTEGER or SQL_DOUBLE the first time
		377	a statement is prepared.
		378
		379	To force a specific type, you can either continue to use e.g. sql casts,
		380	or you can make sure to consistently use strings or numbers. To make a
		381	perl scalar look enough like a string or a number, use this when passing
		382	it to sql_exec or a similar functions:
		383
		384	"$string" # to pass a string
		385	$num+0 # to pass a number
		386
		387	=cut
		388
253	package PApp::SQL::Database;	389	package PApp::SQL::Database;
254		390
255	=head2 THE DATABASE CLASS	391	=head2 The Database Class
256		392
257	Again (sigh) the problem of persistency. What do you do when you have to serialize on object	393	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:	394	to serialize on object that contains (or should contain) a database
		395	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.	396	information to recreate the dbh when needed.
260		397
261	The C<PApp::SQL::Database> class does that, in a relatively efficient	398	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	399	fashion: the overhead is currently a single method call per access (you
263	can cache the real dbh if you want).	400	can cache the real dbh if you want).
264		401
…		…
297		434
298	sub checked_dbh($) {	435	sub checked_dbh($) {
299	my $dbh = $dbcache{$_[0][0]};	436	my $dbh = $dbcache{$_[0][0]};
300	$dbh && $dbh->ping	437	$dbh && $dbh->ping
301	? $dbh	438	? $dbh
302	: PApp::SQL::connect_cached((split /\x00/, $_[0][0]), $_[0][1], $_[0][2]);	439	: PApp::SQL::connect_cached((split /\x00/, $_[0][0], 4), $_[0][1], $_[0][2]);
303	}	440	}
304		441
305	=item $db->dsn	442	=item $db->dsn
306		443
307	Return the DSN (L<DBI>) fo the database object (e.g. for error messages).	444	Return the DSN (L<DBI>) fo the database object (e.g. for error messages).
		445
		446	=item $db->login
		447
		448	Return the login name.
		449
		450	=item $db->password
		451
		452	Return the password (emphasizing the fact that the password is stored plaintext ;)
308		453
309	=cut	454	=cut
310		455
311	sub dsn($) {	456	sub dsn($) {
312	my $self = shift;	457	my $self = shift;
313	$self->[1][1];	458	(split /\x00/, $self->[0])[1];
		459	}
		460
		461	sub login($) {
		462	my $self = shift;
		463	(split /\x00/, $self->[0])[2];
		464	}
		465
		466	sub password($) {
		467	my $self = shift;
		468	(split /\x00/, $self->[0])[3];
314	}	469	}
315		470
316	=back	471	=back
317		472
318	=cut	473	=cut
319		474
320	reinitialize;
321
322	1;	475	1;
323		476
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	477	=head1 SEE ALSO
333		478
334	L<PApp>.	479	L<PApp>.
335		480
336	=head1 AUTHOR	481	=head1 AUTHOR
337		482
338	Marc Lehmann <pcg@goof.com>	483	Marc Lehmann <schmorp@schmorp.de>
339	http://www.goof.com/pcg/marc/	484	http://home.schmorp.de/
340		485
341	=cut	486	=cut
342		487

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.43 by root, Mon Mar 4 06:25:32 2019 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.43 by root, Mon Mar 4 06:25:32 2019 UTC