|
1
|
1 |
<?php |
|
4
|
2 |
|
|
|
3 |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
|
1
|
4 |
|
|
4
|
5 |
/** |
|
|
6 |
* Database independent query interface |
|
|
7 |
* |
|
|
8 |
* PHP versions 4 and 5 |
|
|
9 |
* |
|
|
10 |
* LICENSE: This source file is subject to version 3.0 of the PHP license |
|
|
11 |
* that is available through the world-wide-web at the following URI: |
|
|
12 |
* http://www.php.net/license/3_0.txt. If you did not receive a copy of |
|
|
13 |
* the PHP License and are unable to obtain it through the web, please |
|
|
14 |
* send a note to license@php.net so we can mail you a copy immediately. |
|
|
15 |
* |
|
|
16 |
* @category Database |
|
|
17 |
* @package DB |
|
|
18 |
* @author Stig Bakken <ssb@php.net> |
|
|
19 |
* @author Tomas V.V.Cox <cox@idecnet.com> |
|
|
20 |
* @author Daniel Convissor <danielc@php.net> |
|
|
21 |
* @copyright 1997-2005 The PHP Group |
|
|
22 |
* @license http://www.php.net/license/3_0.txt PHP License 3.0 |
|
|
23 |
* @version CVS: $Id: DB.php,v 1.80 2005/02/16 02:16:00 danielc Exp $ |
|
|
24 |
* @link http://pear.php.net/package/DB |
|
|
25 |
*/ |
|
1
|
26 |
|
|
4
|
27 |
/** |
|
|
28 |
* Obtain the PEAR class so it can be extended from |
|
|
29 |
*/ |
|
|
30 |
require_once 'PEAR.php'; |
|
|
31 |
|
|
|
32 |
|
|
|
33 |
// {{{ constants |
|
|
34 |
// {{{ error codes |
|
|
35 |
|
|
|
36 |
/**#@+ |
|
|
37 |
* One of PEAR DB's portable error codes. |
|
|
38 |
* @see DB_common::errorCode(), DB::errorMessage() |
|
1
|
39 |
* |
|
4
|
40 |
* {@internal If you add an error code here, make sure you also add a textual |
|
|
41 |
* version of it in DB::errorMessage().}} |
|
1
|
42 |
*/ |
|
|
43 |
|
|
4
|
44 |
/** |
|
|
45 |
* The code returned by many methods upon success |
|
|
46 |
*/ |
|
|
47 |
define('DB_OK', 1); |
|
|
48 |
|
|
|
49 |
/** |
|
|
50 |
* Unkown error |
|
|
51 |
*/ |
|
|
52 |
define('DB_ERROR', -1); |
|
|
53 |
|
|
|
54 |
/** |
|
|
55 |
* Syntax error |
|
|
56 |
*/ |
|
|
57 |
define('DB_ERROR_SYNTAX', -2); |
|
|
58 |
|
|
|
59 |
/** |
|
|
60 |
* Tried to insert a duplicate value into a primary or unique index |
|
|
61 |
*/ |
|
|
62 |
define('DB_ERROR_CONSTRAINT', -3); |
|
|
63 |
|
|
|
64 |
/** |
|
|
65 |
* An identifier in the query refers to a non-existant object |
|
|
66 |
*/ |
|
|
67 |
define('DB_ERROR_NOT_FOUND', -4); |
|
|
68 |
|
|
|
69 |
/** |
|
|
70 |
* Tried to create a duplicate object |
|
|
71 |
*/ |
|
|
72 |
define('DB_ERROR_ALREADY_EXISTS', -5); |
|
|
73 |
|
|
|
74 |
/** |
|
|
75 |
* The current driver does not support the action you attempted |
|
|
76 |
*/ |
|
|
77 |
define('DB_ERROR_UNSUPPORTED', -6); |
|
|
78 |
|
|
|
79 |
/** |
|
|
80 |
* The number of parameters does not match the number of placeholders |
|
|
81 |
*/ |
|
|
82 |
define('DB_ERROR_MISMATCH', -7); |
|
|
83 |
|
|
|
84 |
/** |
|
|
85 |
* A literal submitted did not match the data type expected |
|
|
86 |
*/ |
|
|
87 |
define('DB_ERROR_INVALID', -8); |
|
|
88 |
|
|
|
89 |
/** |
|
|
90 |
* The current DBMS does not support the action you attempted |
|
|
91 |
*/ |
|
|
92 |
define('DB_ERROR_NOT_CAPABLE', -9); |
|
|
93 |
|
|
|
94 |
/** |
|
|
95 |
* A literal submitted was too long so the end of it was removed |
|
|
96 |
*/ |
|
|
97 |
define('DB_ERROR_TRUNCATED', -10); |
|
|
98 |
|
|
|
99 |
/** |
|
|
100 |
* A literal number submitted did not match the data type expected |
|
|
101 |
*/ |
|
|
102 |
define('DB_ERROR_INVALID_NUMBER', -11); |
|
|
103 |
|
|
|
104 |
/** |
|
|
105 |
* A literal date submitted did not match the data type expected |
|
|
106 |
*/ |
|
|
107 |
define('DB_ERROR_INVALID_DATE', -12); |
|
|
108 |
|
|
|
109 |
/** |
|
|
110 |
* Attempt to divide something by zero |
|
|
111 |
*/ |
|
|
112 |
define('DB_ERROR_DIVZERO', -13); |
|
|
113 |
|
|
|
114 |
/** |
|
|
115 |
* A database needs to be selected |
|
|
116 |
*/ |
|
|
117 |
define('DB_ERROR_NODBSELECTED', -14); |
|
1
|
118 |
|
|
4
|
119 |
/** |
|
|
120 |
* Could not create the object requested |
|
|
121 |
*/ |
|
|
122 |
define('DB_ERROR_CANNOT_CREATE', -15); |
|
|
123 |
|
|
|
124 |
/** |
|
|
125 |
* Could not drop the database requested because it does not exist |
|
|
126 |
*/ |
|
|
127 |
define('DB_ERROR_CANNOT_DROP', -17); |
|
|
128 |
|
|
|
129 |
/** |
|
|
130 |
* An identifier in the query refers to a non-existant table |
|
|
131 |
*/ |
|
|
132 |
define('DB_ERROR_NOSUCHTABLE', -18); |
|
|
133 |
|
|
|
134 |
/** |
|
|
135 |
* An identifier in the query refers to a non-existant column |
|
|
136 |
*/ |
|
|
137 |
define('DB_ERROR_NOSUCHFIELD', -19); |
|
|
138 |
|
|
|
139 |
/** |
|
|
140 |
* The data submitted to the method was inappropriate |
|
|
141 |
*/ |
|
|
142 |
define('DB_ERROR_NEED_MORE_DATA', -20); |
|
|
143 |
|
|
|
144 |
/** |
|
|
145 |
* The attempt to lock the table failed |
|
|
146 |
*/ |
|
|
147 |
define('DB_ERROR_NOT_LOCKED', -21); |
|
|
148 |
|
|
|
149 |
/** |
|
|
150 |
* The number of columns doesn't match the number of values |
|
|
151 |
*/ |
|
|
152 |
define('DB_ERROR_VALUE_COUNT_ON_ROW', -22); |
|
|
153 |
|
|
|
154 |
/** |
|
|
155 |
* The DSN submitted has problems |
|
|
156 |
*/ |
|
|
157 |
define('DB_ERROR_INVALID_DSN', -23); |
|
|
158 |
|
|
|
159 |
/** |
|
|
160 |
* Could not connect to the database |
|
|
161 |
*/ |
|
|
162 |
define('DB_ERROR_CONNECT_FAILED', -24); |
|
|
163 |
|
|
|
164 |
/** |
|
|
165 |
* The PHP extension needed for this DBMS could not be found |
|
|
166 |
*/ |
|
|
167 |
define('DB_ERROR_EXTENSION_NOT_FOUND',-25); |
|
|
168 |
|
|
|
169 |
/** |
|
|
170 |
* The present user has inadequate permissions to perform the task requestd |
|
|
171 |
*/ |
|
|
172 |
define('DB_ERROR_ACCESS_VIOLATION', -26); |
|
|
173 |
|
|
|
174 |
/** |
|
|
175 |
* The database requested does not exist |
|
|
176 |
*/ |
|
|
177 |
define('DB_ERROR_NOSUCHDB', -27); |
|
|
178 |
|
|
|
179 |
/** |
|
|
180 |
* Tried to insert a null value into a column that doesn't allow nulls |
|
|
181 |
*/ |
|
|
182 |
define('DB_ERROR_CONSTRAINT_NOT_NULL',-29); |
|
|
183 |
/**#@-*/ |
|
|
184 |
|
|
|
185 |
|
|
|
186 |
// }}} |
|
|
187 |
// {{{ prepared statement-related |
|
|
188 |
|
|
|
189 |
|
|
|
190 |
/**#@+ |
|
|
191 |
* Identifiers for the placeholders used in prepared statements. |
|
|
192 |
* @see DB_common::prepare() |
|
1
|
193 |
*/ |
|
|
194 |
|
|
4
|
195 |
/** |
|
|
196 |
* Indicates a scalar (<kbd>?</kbd>) placeholder was used |
|
|
197 |
* |
|
|
198 |
* Quote and escape the value as necessary. |
|
|
199 |
*/ |
|
|
200 |
define('DB_PARAM_SCALAR', 1); |
|
1
|
201 |
|
|
4
|
202 |
/** |
|
|
203 |
* Indicates an opaque (<kbd>&</kbd>) placeholder was used |
|
1
|
204 |
* |
|
4
|
205 |
* The value presented is a file name. Extract the contents of that file |
|
|
206 |
* and place them in this column. |
|
|
207 |
*/ |
|
|
208 |
define('DB_PARAM_OPAQUE', 2); |
|
|
209 |
|
|
|
210 |
/** |
|
|
211 |
* Indicates a misc (<kbd>!</kbd>) placeholder was used |
|
|
212 |
* |
|
|
213 |
* The value should not be quoted or escaped. |
|
|
214 |
*/ |
|
|
215 |
define('DB_PARAM_MISC', 3); |
|
|
216 |
/**#@-*/ |
|
|
217 |
|
|
|
218 |
|
|
|
219 |
// }}} |
|
|
220 |
// {{{ binary data-related |
|
|
221 |
|
|
|
222 |
|
|
|
223 |
/**#@+ |
|
|
224 |
* The different ways of returning binary data from queries. |
|
1
|
225 |
*/ |
|
|
226 |
|
|
4
|
227 |
/** |
|
|
228 |
* Sends the fetched data straight through to output |
|
|
229 |
*/ |
|
|
230 |
define('DB_BINMODE_PASSTHRU', 1); |
|
|
231 |
|
|
|
232 |
/** |
|
|
233 |
* Lets you return data as usual |
|
|
234 |
*/ |
|
|
235 |
define('DB_BINMODE_RETURN', 2); |
|
1
|
236 |
|
|
4
|
237 |
/** |
|
|
238 |
* Converts the data to hex format before returning it |
|
1
|
239 |
* |
|
4
|
240 |
* For example the string "123" would become "313233". |
|
|
241 |
*/ |
|
|
242 |
define('DB_BINMODE_CONVERT', 3); |
|
|
243 |
/**#@-*/ |
|
|
244 |
|
|
|
245 |
|
|
|
246 |
// }}} |
|
|
247 |
// {{{ fetch modes |
|
|
248 |
|
|
|
249 |
|
|
|
250 |
/**#@+ |
|
|
251 |
* Fetch Modes. |
|
|
252 |
* @see DB_common::setFetchMode() |
|
1
|
253 |
*/ |
|
|
254 |
|
|
|
255 |
/** |
|
4
|
256 |
* Indicates the current default fetch mode should be used |
|
|
257 |
* @see DB_common::$fetchmode |
|
1
|
258 |
*/ |
|
|
259 |
define('DB_FETCHMODE_DEFAULT', 0); |
|
|
260 |
|
|
|
261 |
/** |
|
|
262 |
* Column data indexed by numbers, ordered from 0 and up |
|
|
263 |
*/ |
|
|
264 |
define('DB_FETCHMODE_ORDERED', 1); |
|
|
265 |
|
|
|
266 |
/** |
|
|
267 |
* Column data indexed by column names |
|
|
268 |
*/ |
|
|
269 |
define('DB_FETCHMODE_ASSOC', 2); |
|
|
270 |
|
|
|
271 |
/** |
|
|
272 |
* Column data as object properties |
|
|
273 |
*/ |
|
|
274 |
define('DB_FETCHMODE_OBJECT', 3); |
|
|
275 |
|
|
|
276 |
/** |
|
4
|
277 |
* For multi-dimensional results, make the column name the first level |
|
|
278 |
* of the array and put the row number in the second level of the array |
|
|
279 |
* |
|
|
280 |
* This is flipped from the normal behavior, which puts the row numbers |
|
|
281 |
* in the first level of the array and the column names in the second level. |
|
1
|
282 |
*/ |
|
|
283 |
define('DB_FETCHMODE_FLIPPED', 4); |
|
4
|
284 |
/**#@-*/ |
|
1
|
285 |
|
|
4
|
286 |
/**#@+ |
|
|
287 |
* Old fetch modes. Left here for compatibility. |
|
|
288 |
*/ |
|
1
|
289 |
define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED); |
|
|
290 |
define('DB_GETMODE_ASSOC', DB_FETCHMODE_ASSOC); |
|
|
291 |
define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED); |
|
4
|
292 |
/**#@-*/ |
|
1
|
293 |
|
|
4
|
294 |
|
|
|
295 |
// }}} |
|
|
296 |
// {{{ tableInfo() && autoPrepare()-related |
|
|
297 |
|
|
|
298 |
|
|
|
299 |
/**#@+ |
|
|
300 |
* The type of information to return from the tableInfo() method. |
|
|
301 |
* |
|
|
302 |
* Bitwised constants, so they can be combined using <kbd>|</kbd> |
|
|
303 |
* and removed using <kbd>^</kbd>. |
|
|
304 |
* |
|
|
305 |
* @see DB_common::tableInfo() |
|
|
306 |
* |
|
|
307 |
* {@internal Since the TABLEINFO constants are bitwised, if more of them are |
|
|
308 |
* added in the future, make sure to adjust DB_TABLEINFO_FULL accordingly.}} |
|
1
|
309 |
*/ |
|
|
310 |
define('DB_TABLEINFO_ORDER', 1); |
|
|
311 |
define('DB_TABLEINFO_ORDERTABLE', 2); |
|
|
312 |
define('DB_TABLEINFO_FULL', 3); |
|
4
|
313 |
/**#@-*/ |
|
1
|
314 |
|
|
4
|
315 |
|
|
|
316 |
/**#@+ |
|
|
317 |
* The type of query to create with the automatic query building methods. |
|
|
318 |
* @see DB_common::autoPrepare(), DB_common::autoExecute() |
|
1
|
319 |
*/ |
|
|
320 |
define('DB_AUTOQUERY_INSERT', 1); |
|
|
321 |
define('DB_AUTOQUERY_UPDATE', 2); |
|
4
|
322 |
/**#@-*/ |
|
|
323 |
|
|
|
324 |
|
|
|
325 |
// }}} |
|
|
326 |
// {{{ portability modes |
|
1
|
327 |
|
|
|
328 |
|
|
4
|
329 |
/**#@+ |
|
|
330 |
* Portability Modes. |
|
|
331 |
* |
|
|
332 |
* Bitwised constants, so they can be combined using <kbd>|</kbd> |
|
|
333 |
* and removed using <kbd>^</kbd>. |
|
|
334 |
* |
|
|
335 |
* @see DB_common::setOption() |
|
|
336 |
* |
|
|
337 |
* {@internal Since the PORTABILITY constants are bitwised, if more of them are |
|
|
338 |
* added in the future, make sure to adjust DB_PORTABILITY_ALL accordingly.}} |
|
|
339 |
*/ |
|
|
340 |
|
|
1
|
341 |
/** |
|
4
|
342 |
* Turn off all portability features |
|
|
343 |
*/ |
|
|
344 |
define('DB_PORTABILITY_NONE', 0); |
|
|
345 |
|
|
|
346 |
/** |
|
|
347 |
* Convert names of tables and fields to lower case |
|
|
348 |
* when using the get*(), fetch*() and tableInfo() methods |
|
|
349 |
*/ |
|
|
350 |
define('DB_PORTABILITY_LOWERCASE', 1); |
|
|
351 |
|
|
|
352 |
/** |
|
|
353 |
* Right trim the data output by get*() and fetch*() |
|
|
354 |
*/ |
|
|
355 |
define('DB_PORTABILITY_RTRIM', 2); |
|
|
356 |
|
|
|
357 |
/** |
|
|
358 |
* Force reporting the number of rows deleted |
|
|
359 |
*/ |
|
|
360 |
define('DB_PORTABILITY_DELETE_COUNT', 4); |
|
|
361 |
|
|
|
362 |
/** |
|
|
363 |
* Enable hack that makes numRows() work in Oracle |
|
|
364 |
*/ |
|
|
365 |
define('DB_PORTABILITY_NUMROWS', 8); |
|
|
366 |
|
|
|
367 |
/** |
|
|
368 |
* Makes certain error messages in certain drivers compatible |
|
|
369 |
* with those from other DBMS's |
|
|
370 |
* |
|
|
371 |
* + mysql, mysqli: change unique/primary key constraints |
|
|
372 |
* DB_ERROR_ALREADY_EXISTS -> DB_ERROR_CONSTRAINT |
|
|
373 |
* |
|
|
374 |
* + odbc(access): MS's ODBC driver reports 'no such field' as code |
|
|
375 |
* 07001, which means 'too few parameters.' When this option is on |
|
|
376 |
* that code gets mapped to DB_ERROR_NOSUCHFIELD. |
|
|
377 |
*/ |
|
|
378 |
define('DB_PORTABILITY_ERRORS', 16); |
|
|
379 |
|
|
|
380 |
/** |
|
|
381 |
* Convert null values to empty strings in data output by |
|
|
382 |
* get*() and fetch*() |
|
|
383 |
*/ |
|
|
384 |
define('DB_PORTABILITY_NULL_TO_EMPTY', 32); |
|
|
385 |
|
|
|
386 |
/** |
|
|
387 |
* Turn on all portability features |
|
|
388 |
*/ |
|
|
389 |
define('DB_PORTABILITY_ALL', 63); |
|
|
390 |
/**#@-*/ |
|
|
391 |
|
|
|
392 |
// }}} |
|
|
393 |
|
|
|
394 |
|
|
|
395 |
// }}} |
|
|
396 |
// {{{ class DB |
|
|
397 |
|
|
|
398 |
/** |
|
|
399 |
* Database independent query interface |
|
|
400 |
* |
|
1
|
401 |
* The main "DB" class is simply a container class with some static |
|
|
402 |
* methods for creating DB objects as well as some utility functions |
|
|
403 |
* common to all parts of DB. |
|
|
404 |
* |
|
|
405 |
* The object model of DB is as follows (indentation means inheritance): |
|
4
|
406 |
* <pre> |
|
1
|
407 |
* DB The main DB class. This is simply a utility class |
|
|
408 |
* with some "static" methods for creating DB objects as |
|
|
409 |
* well as common utility functions for other DB classes. |
|
|
410 |
* |
|
|
411 |
* DB_common The base for each DB implementation. Provides default |
|
|
412 |
* | implementations (in OO lingo virtual methods) for |
|
|
413 |
* | the actual DB implementations as well as a bunch of |
|
|
414 |
* | query utility functions. |
|
|
415 |
* | |
|
|
416 |
* +-DB_mysql The DB implementation for MySQL. Inherits DB_common. |
|
|
417 |
* When calling DB::factory or DB::connect for MySQL |
|
|
418 |
* connections, the object returned is an instance of this |
|
|
419 |
* class. |
|
4
|
420 |
* </pre> |
|
1
|
421 |
* |
|
4
|
422 |
* @category Database |
|
|
423 |
* @package DB |
|
|
424 |
* @author Stig Bakken <ssb@php.net> |
|
|
425 |
* @author Tomas V.V.Cox <cox@idecnet.com> |
|
|
426 |
* @author Daniel Convissor <danielc@php.net> |
|
|
427 |
* @copyright 1997-2005 The PHP Group |
|
|
428 |
* @license http://www.php.net/license/3_0.txt PHP License 3.0 |
|
|
429 |
* @version Release: @package_version@ |
|
|
430 |
* @link http://pear.php.net/package/DB |
|
1
|
431 |
*/ |
|
|
432 |
class DB |
|
|
433 |
{ |
|
4
|
434 |
// {{{ &factory() |
|
|
435 |
|
|
1
|
436 |
/** |
|
4
|
437 |
* Create a new DB object for the specified database type but don't |
|
|
438 |
* connect to the database |
|
1
|
439 |
* |
|
4
|
440 |
* @param string $type the database type (eg "mysql") |
|
|
441 |
* @param array $options an associative array of option names and values |
|
|
442 |
* |
|
|
443 |
* @return object a new DB object. A DB_Error object on failure. |
|
1
|
444 |
* |
|
4
|
445 |
* @see DB_common::setOption() |
|
1
|
446 |
*/ |
|
4
|
447 |
function &factory($type, $options = false) |
|
|
448 |
{ |
|
|
449 |
if (!is_array($options)) { |
|
|
450 |
$options = array('persistent' => $options); |
|
|
451 |
} |
|
1
|
452 |
|
|
4
|
453 |
if (isset($options['debug']) && $options['debug'] >= 2) { |
|
|
454 |
// expose php errors with sufficient debug level |
|
|
455 |
include_once "DB/{$type}.php"; |
|
|
456 |
} else { |
|
|
457 |
@include_once "DB/{$type}.php"; |
|
|
458 |
} |
|
1
|
459 |
|
|
|
460 |
$classname = "DB_${type}"; |
|
|
461 |
|
|
|
462 |
if (!class_exists($classname)) { |
|
4
|
463 |
$tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null, |
|
|
464 |
"Unable to include the DB/{$type}.php" |
|
|
465 |
. " file for '$dsn'", |
|
|
466 |
'DB_Error', true); |
|
|
467 |
return $tmp; |
|
1
|
468 |
} |
|
|
469 |
|
|
|
470 |
@$obj =& new $classname; |
|
|
471 |
|
|
4
|
472 |
foreach ($options as $option => $value) { |
|
|
473 |
$test = $obj->setOption($option, $value); |
|
|
474 |
if (DB::isError($test)) { |
|
|
475 |
return $test; |
|
|
476 |
} |
|
|
477 |
} |
|
|
478 |
|
|
1
|
479 |
return $obj; |
|
|
480 |
} |
|
|
481 |
|
|
4
|
482 |
// }}} |
|
|
483 |
// {{{ &connect() |
|
|
484 |
|
|
1
|
485 |
/** |
|
4
|
486 |
* Create a new DB object including a connection to the specified database |
|
|
487 |
* |
|
|
488 |
* Example 1. |
|
|
489 |
* <code> |
|
|
490 |
* require_once 'DB.php'; |
|
1
|
491 |
* |
|
4
|
492 |
* $dsn = 'pgsql://user:password@host/database'; |
|
|
493 |
* $options = array( |
|
|
494 |
* 'debug' => 2, |
|
|
495 |
* 'portability' => DB_PORTABILITY_ALL, |
|
|
496 |
* ); |
|
1
|
497 |
* |
|
4
|
498 |
* $db =& DB::connect($dsn, $options); |
|
|
499 |
* if (PEAR::isError($db)) { |
|
|
500 |
* die($db->getMessage()); |
|
|
501 |
* } |
|
|
502 |
* </code> |
|
1
|
503 |
* |
|
4
|
504 |
* @param mixed $dsn the string "data source name" or array in the |
|
|
505 |
* format returned by DB::parseDSN() |
|
|
506 |
* @param array $options an associative array of option names and values |
|
|
507 |
* |
|
|
508 |
* @return object a new DB object. A DB_Error object on failure. |
|
1
|
509 |
* |
|
4
|
510 |
* @uses DB_dbase::connect(), DB_fbsql::connect(), DB_ibase::connect(), |
|
|
511 |
* DB_ifx::connect(), DB_msql::connect(), DB_mssql::connect(), |
|
|
512 |
* DB_mysql::connect(), DB_mysqli::connect(), DB_oci8::connect(), |
|
|
513 |
* DB_odbc::connect(), DB_pgsql::connect(), DB_sqlite::connect(), |
|
|
514 |
* DB_sybase::connect() |
|
|
515 |
* |
|
|
516 |
* @uses DB::parseDSN(), DB_common::setOption(), PEAR::isError() |
|
1
|
517 |
*/ |
|
4
|
518 |
function &connect($dsn, $options = array()) |
|
1
|
519 |
{ |
|
4
|
520 |
$dsninfo = DB::parseDSN($dsn); |
|
|
521 |
$type = $dsninfo['phptype']; |
|
|
522 |
|
|
|
523 |
if (!is_array($options)) { |
|
|
524 |
/* |
|
|
525 |
* For backwards compatibility. $options used to be boolean, |
|
|
526 |
* indicating whether the connection should be persistent. |
|
|
527 |
*/ |
|
|
528 |
$options = array('persistent' => $options); |
|
1
|
529 |
} |
|
|
530 |
|
|
4
|
531 |
if (isset($options['debug']) && $options['debug'] >= 2) { |
|
1
|
532 |
// expose php errors with sufficient debug level |
|
|
533 |
include_once "DB/${type}.php"; |
|
|
534 |
} else { |
|
|
535 |
@include_once "DB/${type}.php"; |
|
|
536 |
} |
|
|
537 |
|
|
|
538 |
$classname = "DB_${type}"; |
|
|
539 |
if (!class_exists($classname)) { |
|
4
|
540 |
$tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null, |
|
|
541 |
"Unable to include the DB/{$type}.php" |
|
|
542 |
. " file for '$dsn'", |
|
1
|
543 |
'DB_Error', true); |
|
4
|
544 |
return $tmp; |
|
1
|
545 |
} |
|
|
546 |
|
|
|
547 |
@$obj =& new $classname; |
|
|
548 |
|
|
4
|
549 |
foreach ($options as $option => $value) { |
|
|
550 |
$test = $obj->setOption($option, $value); |
|
|
551 |
if (DB::isError($test)) { |
|
|
552 |
return $test; |
|
1
|
553 |
} |
|
|
554 |
} |
|
4
|
555 |
|
|
1
|
556 |
$err = $obj->connect($dsninfo, $obj->getOption('persistent')); |
|
|
557 |
if (DB::isError($err)) { |
|
|
558 |
$err->addUserInfo($dsn); |
|
|
559 |
return $err; |
|
|
560 |
} |
|
|
561 |
|
|
|
562 |
return $obj; |
|
|
563 |
} |
|
|
564 |
|
|
4
|
565 |
// }}} |
|
|
566 |
// {{{ apiVersion() |
|
|
567 |
|
|
1
|
568 |
/** |
|
|
569 |
* Return the DB API version |
|
|
570 |
* |
|
4
|
571 |
* @return string the DB API version number |
|
1
|
572 |
*/ |
|
|
573 |
function apiVersion() |
|
|
574 |
{ |
|
4
|
575 |
return '@package_version@'; |
|
1
|
576 |
} |
|
|
577 |
|
|
4
|
578 |
// }}} |
|
|
579 |
// {{{ isError() |
|
|
580 |
|
|
1
|
581 |
/** |
|
4
|
582 |
* Determines if a variable is a DB_Error object |
|
1
|
583 |
* |
|
4
|
584 |
* @param mixed $value the variable to check |
|
1
|
585 |
* |
|
4
|
586 |
* @return bool whether $value is DB_Error object |
|
1
|
587 |
*/ |
|
|
588 |
function isError($value) |
|
|
589 |
{ |
|
4
|
590 |
return is_a($value, 'DB_Error'); |
|
1
|
591 |
} |
|
|
592 |
|
|
4
|
593 |
// }}} |
|
|
594 |
// {{{ isConnection() |
|
|
595 |
|
|
1
|
596 |
/** |
|
4
|
597 |
* Determines if a value is a DB_<driver> object |
|
1
|
598 |
* |
|
4
|
599 |
* @param mixed $value the value to test |
|
1
|
600 |
* |
|
4
|
601 |
* @return bool whether $value is a DB_<driver> object |
|
1
|
602 |
*/ |
|
|
603 |
function isConnection($value) |
|
|
604 |
{ |
|
|
605 |
return (is_object($value) && |
|
|
606 |
is_subclass_of($value, 'db_common') && |
|
|
607 |
method_exists($value, 'simpleQuery')); |
|
|
608 |
} |
|
|
609 |
|
|
4
|
610 |
// }}} |
|
|
611 |
// {{{ isManip() |
|
|
612 |
|
|
1
|
613 |
/** |
|
4
|
614 |
* Tell whether a query is a data manipulation or data definition query |
|
1
|
615 |
* |
|
4
|
616 |
* Examples of data manipulation queries are INSERT, UPDATE and DELETE. |
|
|
617 |
* Examples of data definition queries are CREATE, DROP, ALTER, GRANT, |
|
|
618 |
* REVOKE. |
|
1
|
619 |
* |
|
4
|
620 |
* @param string $query the query |
|
1
|
621 |
* |
|
4
|
622 |
* @return boolean whether $query is a data manipulation query |
|
1
|
623 |
*/ |
|
|
624 |
function isManip($query) |
|
|
625 |
{ |
|
4
|
626 |
$manips = 'INSERT|UPDATE|DELETE|REPLACE|' |
|
|
627 |
. 'CREATE|DROP|' |
|
|
628 |
. 'LOAD DATA|SELECT .* INTO|COPY|' |
|
|
629 |
. 'ALTER|GRANT|REVOKE|' |
|
|
630 |
. 'LOCK|UNLOCK'; |
|
|
631 |
if (preg_match('/^\s*"?(' . $manips . ')\s+/i', $query)) { |
|
1
|
632 |
return true; |
|
|
633 |
} |
|
|
634 |
return false; |
|
|
635 |
} |
|
|
636 |
|
|
4
|
637 |
// }}} |
|
|
638 |
// {{{ errorMessage() |
|
|
639 |
|
|
1
|
640 |
/** |
|
|
641 |
* Return a textual error message for a DB error code |
|
|
642 |
* |
|
4
|
643 |
* @param integer $value the DB error code |
|
1
|
644 |
* |
|
4
|
645 |
* @return string the error message or false if the error code was |
|
|
646 |
* not recognized |
|
1
|
647 |
*/ |
|
|
648 |
function errorMessage($value) |
|
|
649 |
{ |
|
|
650 |
static $errorMessages; |
|
|
651 |
if (!isset($errorMessages)) { |
|
|
652 |
$errorMessages = array( |
|
|
653 |
DB_ERROR => 'unknown error', |
|
4
|
654 |
DB_ERROR_ACCESS_VIOLATION => 'insufficient permissions', |
|
1
|
655 |
DB_ERROR_ALREADY_EXISTS => 'already exists', |
|
|
656 |
DB_ERROR_CANNOT_CREATE => 'can not create', |
|
|
657 |
DB_ERROR_CANNOT_DROP => 'can not drop', |
|
4
|
658 |
DB_ERROR_CONNECT_FAILED => 'connect failed', |
|
1
|
659 |
DB_ERROR_CONSTRAINT => 'constraint violation', |
|
4
|
660 |
DB_ERROR_CONSTRAINT_NOT_NULL=> 'null value violates not-null constraint', |
|
1
|
661 |
DB_ERROR_DIVZERO => 'division by zero', |
|
4
|
662 |
DB_ERROR_EXTENSION_NOT_FOUND=> 'extension not found', |
|
1
|
663 |
DB_ERROR_INVALID => 'invalid', |
|
|
664 |
DB_ERROR_INVALID_DATE => 'invalid date or time', |
|
4
|
665 |
DB_ERROR_INVALID_DSN => 'invalid DSN', |
|
1
|
666 |
DB_ERROR_INVALID_NUMBER => 'invalid number', |
|
|
667 |
DB_ERROR_MISMATCH => 'mismatch', |
|
4
|
668 |
DB_ERROR_NEED_MORE_DATA => 'insufficient data supplied', |
|
1
|
669 |
DB_ERROR_NODBSELECTED => 'no database selected', |
|
4
|
670 |
DB_ERROR_NOSUCHDB => 'no such database', |
|
1
|
671 |
DB_ERROR_NOSUCHFIELD => 'no such field', |
|
|
672 |
DB_ERROR_NOSUCHTABLE => 'no such table', |
|
|
673 |
DB_ERROR_NOT_CAPABLE => 'DB backend not capable', |
|
|
674 |
DB_ERROR_NOT_FOUND => 'not found', |
|
|
675 |
DB_ERROR_NOT_LOCKED => 'not locked', |
|
|
676 |
DB_ERROR_SYNTAX => 'syntax error', |
|
|
677 |
DB_ERROR_UNSUPPORTED => 'not supported', |
|
4
|
678 |
DB_ERROR_TRUNCATED => 'truncated', |
|
1
|
679 |
DB_ERROR_VALUE_COUNT_ON_ROW => 'value count on row', |
|
|
680 |
DB_OK => 'no error', |
|
|
681 |
); |
|
|
682 |
} |
|
|
683 |
|
|
|
684 |
if (DB::isError($value)) { |
|
|
685 |
$value = $value->getCode(); |
|
|
686 |
} |
|
|
687 |
|
|
4
|
688 |
return isset($errorMessages[$value]) ? $errorMessages[$value] |
|
|
689 |
: $errorMessages[DB_ERROR]; |
|
1
|
690 |
} |
|
|
691 |
|
|
4
|
692 |
// }}} |
|
|
693 |
// {{{ parseDSN() |
|
|
694 |
|
|
1
|
695 |
/** |
|
|
696 |
* Parse a data source name |
|
|
697 |
* |
|
4
|
698 |
* Additional keys can be added by appending a URI query string to the |
|
|
699 |
* end of the DSN. |
|
1
|
700 |
* |
|
|
701 |
* The format of the supplied DSN is in its fullest form: |
|
4
|
702 |
* <code> |
|
|
703 |
* phptype(dbsyntax)://username:password@protocol+hostspec/database?option=8&another=true |
|
|
704 |
* </code> |
|
1
|
705 |
* |
|
|
706 |
* Most variations are allowed: |
|
4
|
707 |
* <code> |
|
|
708 |
* phptype://username:password@protocol+hostspec:110//usr/db_file.db?mode=0644 |
|
1
|
709 |
* phptype://username:password@hostspec/database_name |
|
|
710 |
* phptype://username:password@hostspec |
|
|
711 |
* phptype://username@hostspec |
|
|
712 |
* phptype://hostspec/database |
|
|
713 |
* phptype://hostspec |
|
|
714 |
* phptype(dbsyntax) |
|
|
715 |
* phptype |
|
4
|
716 |
* </code> |
|
1
|
717 |
* |
|
|
718 |
* @param string $dsn Data Source Name to be parsed |
|
|
719 |
* |
|
4
|
720 |
* @return array an associative array with the following keys: |
|
|
721 |
* + phptype: Database backend used in PHP (mysql, odbc etc.) |
|
|
722 |
* + dbsyntax: Database used with regards to SQL syntax etc. |
|
|
723 |
* + protocol: Communication protocol to use (tcp, unix etc.) |
|
|
724 |
* + hostspec: Host specification (hostname[:port]) |
|
|
725 |
* + database: Database to use on the DBMS server |
|
|
726 |
* + username: User name for login |
|
|
727 |
* + password: Password for login |
|
1
|
728 |
*/ |
|
|
729 |
function parseDSN($dsn) |
|
|
730 |
{ |
|
|
731 |
$parsed = array( |
|
|
732 |
'phptype' => false, |
|
|
733 |
'dbsyntax' => false, |
|
|
734 |
'username' => false, |
|
|
735 |
'password' => false, |
|
|
736 |
'protocol' => false, |
|
|
737 |
'hostspec' => false, |
|
|
738 |
'port' => false, |
|
|
739 |
'socket' => false, |
|
4
|
740 |
'database' => false, |
|
1
|
741 |
); |
|
|
742 |
|
|
4
|
743 |
if (is_array($dsn)) { |
|
|
744 |
$dsn = array_merge($parsed, $dsn); |
|
|
745 |
if (!$dsn['dbsyntax']) { |
|
|
746 |
$dsn['dbsyntax'] = $dsn['phptype']; |
|
|
747 |
} |
|
|
748 |
return $dsn; |
|
|
749 |
} |
|
|
750 |
|
|
1
|
751 |
// Find phptype and dbsyntax |
|
|
752 |
if (($pos = strpos($dsn, '://')) !== false) { |
|
|
753 |
$str = substr($dsn, 0, $pos); |
|
|
754 |
$dsn = substr($dsn, $pos + 3); |
|
|
755 |
} else { |
|
|
756 |
$str = $dsn; |
|
4
|
757 |
$dsn = null; |
|
1
|
758 |
} |
|
|
759 |
|
|
|
760 |
// Get phptype and dbsyntax |
|
|
761 |
// $str => phptype(dbsyntax) |
|
|
762 |
if (preg_match('|^(.+?)\((.*?)\)$|', $str, $arr)) { |
|
|
763 |
$parsed['phptype'] = $arr[1]; |
|
4
|
764 |
$parsed['dbsyntax'] = !$arr[2] ? $arr[1] : $arr[2]; |
|
1
|
765 |
} else { |
|
|
766 |
$parsed['phptype'] = $str; |
|
|
767 |
$parsed['dbsyntax'] = $str; |
|
|
768 |
} |
|
|
769 |
|
|
4
|
770 |
if (!count($dsn)) { |
|
1
|
771 |
return $parsed; |
|
|
772 |
} |
|
|
773 |
|
|
|
774 |
// Get (if found): username and password |
|
|
775 |
// $dsn => username:password@protocol+hostspec/database |
|
|
776 |
if (($at = strrpos($dsn,'@')) !== false) { |
|
|
777 |
$str = substr($dsn, 0, $at); |
|
|
778 |
$dsn = substr($dsn, $at + 1); |
|
|
779 |
if (($pos = strpos($str, ':')) !== false) { |
|
4
|
780 |
$parsed['username'] = rawurldecode(substr($str, 0, $pos)); |
|
|
781 |
$parsed['password'] = rawurldecode(substr($str, $pos + 1)); |
|
1
|
782 |
} else { |
|
4
|
783 |
$parsed['username'] = rawurldecode($str); |
|
1
|
784 |
} |
|
|
785 |
} |
|
|
786 |
|
|
|
787 |
// Find protocol and hostspec |
|
|
788 |
|
|
|
789 |
if (preg_match('|^([^(]+)\((.*?)\)/?(.*?)$|', $dsn, $match)) { |
|
4
|
790 |
// $dsn => proto(proto_opts)/database |
|
1
|
791 |
$proto = $match[1]; |
|
4
|
792 |
$proto_opts = $match[2] ? $match[2] : false; |
|
1
|
793 |
$dsn = $match[3]; |
|
|
794 |
|
|
|
795 |
} else { |
|
4
|
796 |
// $dsn => protocol+hostspec/database (old format) |
|
1
|
797 |
if (strpos($dsn, '+') !== false) { |
|
|
798 |
list($proto, $dsn) = explode('+', $dsn, 2); |
|
|
799 |
} |
|
|
800 |
if (strpos($dsn, '/') !== false) { |
|
|
801 |
list($proto_opts, $dsn) = explode('/', $dsn, 2); |
|
|
802 |
} else { |
|
|
803 |
$proto_opts = $dsn; |
|
|
804 |
$dsn = null; |
|
|
805 |
} |
|
|
806 |
} |
|
|
807 |
|
|
|
808 |
// process the different protocol options |
|
|
809 |
$parsed['protocol'] = (!empty($proto)) ? $proto : 'tcp'; |
|
4
|
810 |
$proto_opts = rawurldecode($proto_opts); |
|
1
|
811 |
if ($parsed['protocol'] == 'tcp') { |
|
|
812 |
if (strpos($proto_opts, ':') !== false) { |
|
4
|
813 |
list($parsed['hostspec'], |
|
|
814 |
$parsed['port']) = explode(':', $proto_opts); |
|
1
|
815 |
} else { |
|
|
816 |
$parsed['hostspec'] = $proto_opts; |
|
|
817 |
} |
|
|
818 |
} elseif ($parsed['protocol'] == 'unix') { |
|
|
819 |
$parsed['socket'] = $proto_opts; |
|
|
820 |
} |
|
|
821 |
|
|
|
822 |
// Get dabase if any |
|
|
823 |
// $dsn => database |
|
4
|
824 |
if ($dsn) { |
|
1
|
825 |
if (($pos = strpos($dsn, '?')) === false) { |
|
4
|
826 |
// /database |
|
|
827 |
$parsed['database'] = rawurldecode($dsn); |
|
1
|
828 |
} else { |
|
4
|
829 |
// /database?param1=value1¶m2=value2 |
|
|
830 |
$parsed['database'] = rawurldecode(substr($dsn, 0, $pos)); |
|
1
|
831 |
$dsn = substr($dsn, $pos + 1); |
|
|
832 |
if (strpos($dsn, '&') !== false) { |
|
|
833 |
$opts = explode('&', $dsn); |
|
|
834 |
} else { // database?param1=value1 |
|
|
835 |
$opts = array($dsn); |
|
|
836 |
} |
|
|
837 |
foreach ($opts as $opt) { |
|
|
838 |
list($key, $value) = explode('=', $opt); |
|
4
|
839 |
if (!isset($parsed[$key])) { |
|
|
840 |
// don't allow params overwrite |
|
|
841 |
$parsed[$key] = rawurldecode($value); |
|
1
|
842 |
} |
|
|
843 |
} |
|
|
844 |
} |
|
|
845 |
} |
|
|
846 |
|
|
|
847 |
return $parsed; |
|
|
848 |
} |
|
|
849 |
|
|
4
|
850 |
// }}} |
|
1
|
851 |
} |
|
|
852 |
|
|
4
|
853 |
// }}} |
|
|
854 |
// {{{ class DB_Error |
|
|
855 |
|
|
1
|
856 |
/** |
|
|
857 |
* DB_Error implements a class for reporting portable database error |
|
4
|
858 |
* messages |
|
1
|
859 |
* |
|
4
|
860 |
* @category Database |
|
|
861 |
* @package DB |
|
|
862 |
* @author Stig Bakken <ssb@php.net> |
|
|
863 |
* @copyright 1997-2005 The PHP Group |
|
|
864 |
* @license http://www.php.net/license/3_0.txt PHP License 3.0 |
|
|
865 |
* @version Release: @package_version@ |
|
|
866 |
* @link http://pear.php.net/package/DB |
|
1
|
867 |
*/ |
|
|
868 |
class DB_Error extends PEAR_Error |
|
|
869 |
{ |
|
4
|
870 |
// {{{ constructor |
|
|
871 |
|
|
1
|
872 |
/** |
|
4
|
873 |
* DB_Error constructor |
|
1
|
874 |
* |
|
4
|
875 |
* @param mixed $code DB error code, or string with error message |
|
|
876 |
* @param int $mode what "error mode" to operate in |
|
|
877 |
* @param int $level what error level to use for $mode & |
|
|
878 |
* PEAR_ERROR_TRIGGER |
|
|
879 |
* @param mixed $debuginfo additional debug info, such as the last query |
|
1
|
880 |
* |
|
|
881 |
* @see PEAR_Error |
|
|
882 |
*/ |
|
|
883 |
function DB_Error($code = DB_ERROR, $mode = PEAR_ERROR_RETURN, |
|
4
|
884 |
$level = E_USER_NOTICE, $debuginfo = null) |
|
1
|
885 |
{ |
|
|
886 |
if (is_int($code)) { |
|
4
|
887 |
$this->PEAR_Error('DB Error: ' . DB::errorMessage($code), $code, |
|
|
888 |
$mode, $level, $debuginfo); |
|
1
|
889 |
} else { |
|
4
|
890 |
$this->PEAR_Error("DB Error: $code", DB_ERROR, |
|
|
891 |
$mode, $level, $debuginfo); |
|
1
|
892 |
} |
|
|
893 |
} |
|
4
|
894 |
|
|
|
895 |
// }}} |
|
1
|
896 |
} |
|
|
897 |
|
|
4
|
898 |
// }}} |
|
|
899 |
// {{{ class DB_result |
|
|
900 |
|
|
1
|
901 |
/** |
|
4
|
902 |
* This class implements a wrapper for a DB result set |
|
|
903 |
* |
|
1
|
904 |
* A new instance of this class will be returned by the DB implementation |
|
|
905 |
* after processing a query that returns data. |
|
|
906 |
* |
|
4
|
907 |
* @category Database |
|
|
908 |
* @package DB |
|
|
909 |
* @author Stig Bakken <ssb@php.net> |
|
|
910 |
* @copyright 1997-2005 The PHP Group |
|
|
911 |
* @license http://www.php.net/license/3_0.txt PHP License 3.0 |
|
|
912 |
* @version Release: @package_version@ |
|
|
913 |
* @link http://pear.php.net/package/DB |
|
1
|
914 |
*/ |
|
|
915 |
class DB_result |
|
|
916 |
{ |
|
4
|
917 |
// {{{ properties |
|
|
918 |
|
|
1
|
919 |
/** |
|
4
|
920 |
* Should results be freed automatically when there are no more rows? |
|
|
921 |
* @var boolean |
|
|
922 |
* @see DB_common::$options |
|
|
923 |
*/ |
|
|
924 |
var $autofree; |
|
|
925 |
|
|
|
926 |
/** |
|
|
927 |
* A reference to the DB_<driver> object |
|
|
928 |
* @var object |
|
|
929 |
*/ |
|
|
930 |
var $dbh; |
|
1
|
931 |
|
|
|
932 |
/** |
|
4
|
933 |
* The current default fetch mode |
|
|
934 |
* @var integer |
|
|
935 |
* @see DB_common::$fetchmode |
|
|
936 |
*/ |
|
|
937 |
var $fetchmode; |
|
|
938 |
|
|
|
939 |
/** |
|
|
940 |
* The name of the class into which results should be fetched when |
|
|
941 |
* DB_FETCHMODE_OBJECT is in effect |
|
|
942 |
* |
|
|
943 |
* @var string |
|
|
944 |
* @see DB_common::$fetchmode_object_class |
|
|
945 |
*/ |
|
|
946 |
var $fetchmode_object_class; |
|
|
947 |
|
|
|
948 |
/** |
|
|
949 |
* The number of rows to fetch from a limit query |
|
|
950 |
* @var integer |
|
|
951 |
*/ |
|
1
|
952 |
var $limit_count = null; |
|
|
953 |
|
|
|
954 |
/** |
|
4
|
955 |
* The row to start fetching from in limit queries |
|
|
956 |
* @var integer |
|
|
957 |
*/ |
|
|
958 |
var $limit_from = null; |
|
|
959 |
|
|
|
960 |
/** |
|
|
961 |
* The execute parameters that created this result |
|
|
962 |
* @var array |
|
|
963 |
* @since Property available since Release 1.7.0 |
|
|
964 |
*/ |
|
|
965 |
var $parameters; |
|
|
966 |
|
|
|
967 |
/** |
|
|
968 |
* The query string that created this result |
|
|
969 |
* |
|
|
970 |
* Copied here incase it changes in $dbh, which is referenced |
|
|
971 |
* |
|
|
972 |
* @var string |
|
|
973 |
* @since Property available since Release 1.7.0 |
|
|
974 |
*/ |
|
|
975 |
var $query; |
|
|
976 |
|
|
|
977 |
/** |
|
|
978 |
* The query result resource id created by PHP |
|
|
979 |
* @var resource |
|
|
980 |
*/ |
|
|
981 |
var $result; |
|
|
982 |
|
|
|
983 |
/** |
|
|
984 |
* The present row being dealt with |
|
|
985 |
* @var integer |
|
1
|
986 |
*/ |
|
4
|
987 |
var $row_counter = null; |
|
1
|
988 |
|
|
4
|
989 |
/** |
|
|
990 |
* The prepared statement resource id created by PHP in $dbh |
|
|
991 |
* |
|
|
992 |
* This resource is only available when the result set was created using |
|
|
993 |
* a driver's native execute() method, not PEAR DB's emulated one. |
|
|
994 |
* |
|
|
995 |
* Copied here incase it changes in $dbh, which is referenced |
|
|
996 |
* |
|
|
997 |
* {@internal Mainly here because the InterBase/Firebird API is only |
|
|
998 |
* able to retrieve data from result sets if the statemnt handle is |
|
|
999 |
* still in scope.}} |
|
|
1000 |
* |
|
|
1001 |
* @var resource |
|
|
1002 |
* @since Property available since Release 1.7.0 |
|
|
1003 |
*/ |
|
|
1004 |
var $statement; |
|
|
1005 |
|
|
|
1006 |
|
|
|
1007 |
// }}} |
|
|
1008 |
// {{{ constructor |
|
|
1009 |
|
|
|
1010 |
/** |
|
|
1011 |
* This constructor sets the object's properties |
|
|
1012 |
* |
|
|
1013 |
* @param object &$dbh the DB object reference |
|
|
1014 |
* @param resource $result the result resource id |
|
|
1015 |
* @param array $options an associative array with result options |
|
|
1016 |
* |
|
|
1017 |
* @return void |
|
|
1018 |
*/ |
|
1
|
1019 |
function DB_result(&$dbh, $result, $options = array()) |
|
|
1020 |
{ |
|
|
1021 |
$this->autofree = $dbh->options['autofree']; |
|
4
|
1022 |
$this->dbh = &$dbh; |
|
1
|
1023 |
$this->fetchmode = $dbh->fetchmode; |
|
|
1024 |
$this->fetchmode_object_class = $dbh->fetchmode_object_class; |
|
4
|
1025 |
$this->parameters = $dbh->last_parameters; |
|
|
1026 |
$this->query = $dbh->last_query; |
|
|
1027 |
$this->result = $result; |
|
|
1028 |
$this->statement = empty($dbh->last_stmt) ? null : $dbh->last_stmt; |
|
|
1029 |
foreach ($options as $key => $value) { |
|
|
1030 |
$this->setOption($key, $value); |
|
|
1031 |
} |
|
1
|
1032 |
} |
|
|
1033 |
|
|
|
1034 |
/** |
|
4
|
1035 |
* Set options for the DB_result object |
|
|
1036 |
* |
|
|
1037 |
* @param string $key the option to set |
|
|
1038 |
* @param mixed $value the value to set the option to |
|
|
1039 |
* |
|
|
1040 |
* @return void |
|
|
1041 |
*/ |
|
|
1042 |
function setOption($key, $value = null) |
|
|
1043 |
{ |
|
|
1044 |
switch ($key) { |
|
|
1045 |
case 'limit_from': |
|
|
1046 |
$this->limit_from = $value; |
|
|
1047 |
break; |
|
|
1048 |
case 'limit_count': |
|
|
1049 |
$this->limit_count = $value; |
|
|
1050 |
} |
|
|
1051 |
} |
|
|
1052 |
|
|
|
1053 |
// }}} |
|
|
1054 |
// {{{ fetchRow() |
|
|
1055 |
|
|
|
1056 |
/** |
|
|
1057 |
* Fetch a row of data and return it by reference into an array |
|
1
|
1058 |
* |
|
4
|
1059 |
* The type of array returned can be controlled either by setting this |
|
|
1060 |
* method's <var>$fetchmode</var> parameter or by changing the default |
|
|
1061 |
* fetch mode setFetchMode() before calling this method. |
|
|
1062 |
* |
|
|
1063 |
* There are two options for standardizing the information returned |
|
|
1064 |
* from databases, ensuring their values are consistent when changing |
|
|
1065 |
* DBMS's. These portability options can be turned on when creating a |
|
|
1066 |
* new DB object or by using setOption(). |
|
|
1067 |
* |
|
|
1068 |
* + <var>DB_PORTABILITY_LOWERCASE</var> |
|
|
1069 |
* convert names of fields to lower case |
|
1
|
1070 |
* |
|
4
|
1071 |
* + <var>DB_PORTABILITY_RTRIM</var> |
|
|
1072 |
* right trim the data |
|
|
1073 |
* |
|
|
1074 |
* @param int $fetchmode the constant indicating how to format the data |
|
|
1075 |
* @param int $rownum the row number to fetch (index starts at 0) |
|
|
1076 |
* |
|
|
1077 |
* @return mixed an array or object containing the row's data, |
|
|
1078 |
* NULL when the end of the result set is reached |
|
|
1079 |
* or a DB_Error object on failure. |
|
|
1080 |
* |
|
|
1081 |
* @see DB_common::setOption(), DB_common::setFetchMode() |
|
1
|
1082 |
*/ |
|
4
|
1083 |
function &fetchRow($fetchmode = DB_FETCHMODE_DEFAULT, $rownum = null) |
|
1
|
1084 |
{ |
|
|
1085 |
if ($fetchmode === DB_FETCHMODE_DEFAULT) { |
|
|
1086 |
$fetchmode = $this->fetchmode; |
|
|
1087 |
} |
|
|
1088 |
if ($fetchmode === DB_FETCHMODE_OBJECT) { |
|
|
1089 |
$fetchmode = DB_FETCHMODE_ASSOC; |
|
|
1090 |
$object_class = $this->fetchmode_object_class; |
|
|
1091 |
} |
|
|
1092 |
if ($this->limit_from !== null) { |
|
|
1093 |
if ($this->row_counter === null) { |
|
|
1094 |
$this->row_counter = $this->limit_from; |
|
|
1095 |
// Skip rows |
|
4
|
1096 |
if ($this->dbh->features['limit'] === false) { |
|
1
|
1097 |
$i = 0; |
|
|
1098 |
while ($i++ < $this->limit_from) { |
|
|
1099 |
$this->dbh->fetchInto($this->result, $arr, $fetchmode); |
|
|
1100 |
} |
|
|
1101 |
} |
|
|
1102 |
} |
|
4
|
1103 |
if ($this->row_counter >= ($this->limit_from + $this->limit_count)) |
|
1
|
1104 |
{ |
|
4
|
1105 |
if ($this->autofree) { |
|
|
1106 |
$this->free(); |
|
|
1107 |
} |
|
|
1108 |
$tmp = null; |
|
|
1109 |
return $tmp; |
|
1
|
1110 |
} |
|
4
|
1111 |
if ($this->dbh->features['limit'] === 'emulate') { |
|
1
|
1112 |
$rownum = $this->row_counter; |
|
|
1113 |
} |
|
|
1114 |
$this->row_counter++; |
|
|
1115 |
} |
|
|
1116 |
$res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum); |
|
4
|
1117 |
if ($res === DB_OK) { |
|
|
1118 |
if (isset($object_class)) { |
|
|
1119 |
// The default mode is specified in the |
|
|
1120 |
// DB_common::fetchmode_object_class property |
|
|
1121 |
if ($object_class == 'stdClass') { |
|
|
1122 |
$arr = (object) $arr; |
|
|
1123 |
} else { |
|
|
1124 |
$arr = &new $object_class($arr); |
|
|
1125 |
} |
|
1
|
1126 |
} |
|
4
|
1127 |
return $arr; |
|
1
|
1128 |
} |
|
4
|
1129 |
if ($res == null && $this->autofree) { |
|
|
1130 |
$this->free(); |
|
1
|
1131 |
} |
|
4
|
1132 |
return $res; |
|
1
|
1133 |
} |
|
|
1134 |
|
|
4
|
1135 |
// }}} |
|
|
1136 |
// {{{ fetchInto() |
|
|
1137 |
|
|
1
|
1138 |
/** |
|
4
|
1139 |
* Fetch a row of data into an array which is passed by reference |
|
1
|
1140 |
* |
|
4
|
1141 |
* The type of array returned can be controlled either by setting this |
|
|
1142 |
* method's <var>$fetchmode</var> parameter or by changing the default |
|
|
1143 |
* fetch mode setFetchMode() before calling this method. |
|
|
1144 |
* |
|
|
1145 |
* There are two options for standardizing the information returned |
|
|
1146 |
* from databases, ensuring their values are consistent when changing |
|
|
1147 |
* DBMS's. These portability options can be turned on when creating a |
|
|
1148 |
* new DB object or by using setOption(). |
|
1
|
1149 |
* |
|
4
|
1150 |
* + <var>DB_PORTABILITY_LOWERCASE</var> |
|
|
1151 |
* convert names of fields to lower case |
|
|
1152 |
* |
|
|
1153 |
* + <var>DB_PORTABILITY_RTRIM</var> |
|
|
1154 |
* right trim the data |
|
1
|
1155 |
* |
|
4
|
1156 |
* @param array &$arr the variable where the data should be placed |
|
|
1157 |
* @param int $fetchmode the constant indicating how to format the data |
|
|
1158 |
* @param int $rownum the row number to fetch (index starts at 0) |
|
|
1159 |
* |
|
|
1160 |
* @return mixed DB_OK if a row is processed, NULL when the end of the |
|
|
1161 |
* result set is reached or a DB_Error object on failure |
|
|
1162 |
* |
|
|
1163 |
* @see DB_common::setOption(), DB_common::setFetchMode() |
|
1
|
1164 |
*/ |
|
4
|
1165 |
function fetchInto(&$arr, $fetchmode = DB_FETCHMODE_DEFAULT, $rownum = null) |
|
1
|
1166 |
{ |
|
|
1167 |
if ($fetchmode === DB_FETCHMODE_DEFAULT) { |
|
|
1168 |
$fetchmode = $this->fetchmode; |
|
|
1169 |
} |
|
|
1170 |
if ($fetchmode === DB_FETCHMODE_OBJECT) { |
|
|
1171 |
$fetchmode = DB_FETCHMODE_ASSOC; |
|
|
1172 |
$object_class = $this->fetchmode_object_class; |
|
|
1173 |
} |
|
|
1174 |
if ($this->limit_from !== null) { |
|
|
1175 |
if ($this->row_counter === null) { |
|
|
1176 |
$this->row_counter = $this->limit_from; |
|
|
1177 |
// Skip rows |
|
4
|
1178 |
if ($this->dbh->features['limit'] === false) { |
|
1
|
1179 |
$i = 0; |
|
|
1180 |
while ($i++ < $this->limit_from) { |
|
|
1181 |
$this->dbh->fetchInto($this->result, $arr, $fetchmode); |
|
|
1182 |
} |
|
|
1183 |
} |
|
|
1184 |
} |
|
|
1185 |
if ($this->row_counter >= ( |
|
|
1186 |
$this->limit_from + $this->limit_count)) |
|
|
1187 |
{ |
|
4
|
1188 |
if ($this->autofree) { |
|
|
1189 |
$this->free(); |
|
|
1190 |
} |
|
1
|
1191 |
return null; |
|
|
1192 |
} |
|
4
|
1193 |
if ($this->dbh->features['limit'] === 'emulate') { |
|
1
|
1194 |
$rownum = $this->row_counter; |
|
|
1195 |
} |
|
|
1196 |
|
|
|
1197 |
$this->row_counter++; |
|
|
1198 |
} |
|
|
1199 |
$res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum); |
|
4
|
1200 |
if ($res === DB_OK) { |
|
|
1201 |
if (isset($object_class)) { |
|
|
1202 |
// default mode specified in the |
|
|
1203 |
// DB_common::fetchmode_object_class property |
|
|
1204 |
if ($object_class == 'stdClass') { |
|
|
1205 |
$arr = (object) $arr; |
|
|
1206 |
} else { |
|
|
1207 |
$arr = new $object_class($arr); |
|
|
1208 |
} |
|
1
|
1209 |
} |
|
4
|
1210 |
return DB_OK; |
|
|
1211 |
} |
|
|
1212 |
if ($res == null && $this->autofree) { |
|
1
|
1213 |
$this->free(); |
|
|
1214 |
} |
|
|
1215 |
return $res; |
|
|
1216 |
} |
|
|
1217 |
|
|
4
|
1218 |
// }}} |
|
|
1219 |
// {{{ numCols() |
|
|
1220 |
|
|
1
|
1221 |
/** |
|
4
|
1222 |
* Get the the number of columns in a result set |
|
1
|
1223 |
* |
|
4
|
1224 |
* @return int the number of columns. A DB_Error object on failure. |
|
1
|
1225 |
*/ |
|
|
1226 |
function numCols() |
|
|
1227 |
{ |
|
|
1228 |
return $this->dbh->numCols($this->result); |
|
|
1229 |
} |
|
|
1230 |
|
|
4
|
1231 |
// }}} |
|
|
1232 |
// {{{ numRows() |
|
|
1233 |
|
|
1
|
1234 |
/** |
|
4
|
1235 |
* Get the number of rows in a result set |
|
1
|
1236 |
* |
|
4
|
1237 |
* @return int the number of rows. A DB_Error object on failure. |
|
1
|
1238 |
*/ |
|
|
1239 |
function numRows() |
|
|
1240 |
{ |
|
4
|
1241 |
if ($this->dbh->features['numrows'] === 'emulate' |
|
|
1242 |
&& $this->dbh->options['portability'] & DB_PORTABILITY_NUMROWS) |
|
|
1243 |
{ |
|
|
1244 |
if ($this->dbh->features['prepare']) { |
|
|
1245 |
$res = $this->dbh->query($this->query, $this->parameters); |
|
|
1246 |
} else { |
|
|
1247 |
$res = $this->dbh->query($this->query); |
|
|
1248 |
} |
|
|
1249 |
if (DB::isError($res)) { |
|
|
1250 |
return $res; |
|
|
1251 |
} |
|
|
1252 |
$i = 0; |
|
|
1253 |
while ($res->fetchInto($tmp, DB_FETCHMODE_ORDERED)) { |
|
|
1254 |
$i++; |
|
|
1255 |
} |
|
|
1256 |
return $i; |
|
|
1257 |
} else { |
|
|
1258 |
return $this->dbh->numRows($this->result); |
|
|
1259 |
} |
|
1
|
1260 |
} |
|
|
1261 |
|
|
4
|
1262 |
// }}} |
|
|
1263 |
// {{{ nextResult() |
|
|
1264 |
|
|
1
|
1265 |
/** |
|
4
|
1266 |
* Get the next result if a batch of queries was executed |
|
1
|
1267 |
* |
|
4
|
1268 |
* @return bool true if a new result is available or false if not |
|
1
|
1269 |
*/ |
|
|
1270 |
function nextResult() |
|
|
1271 |
{ |
|
|
1272 |
return $this->dbh->nextResult($this->result); |
|
|
1273 |
} |
|
|
1274 |
|
|
4
|
1275 |
// }}} |
|
|
1276 |
// {{{ free() |
|
|
1277 |
|
|
1
|
1278 |
/** |
|
4
|
1279 |
* Frees the resources allocated for this result set |
|
1
|
1280 |
* |
|
4
|
1281 |
* @return bool true on success. A DB_Error object on failure. |
|
1
|
1282 |
*/ |
|
|
1283 |
function free() |
|
|
1284 |
{ |
|
|
1285 |
$err = $this->dbh->freeResult($this->result); |
|
4
|
1286 |
if (DB::isError($err)) { |
|
1
|
1287 |
return $err; |
|
|
1288 |
} |
|
|
1289 |
$this->result = false; |
|
4
|
1290 |
$this->statement = false; |
|
1
|
1291 |
return true; |
|
|
1292 |
} |
|
|
1293 |
|
|
4
|
1294 |
// }}} |
|
|
1295 |
// {{{ tableInfo() |
|
|
1296 |
|
|
1
|
1297 |
/** |
|
4
|
1298 |
* @see DB_common::tableInfo() |
|
|
1299 |
* @deprecated Method deprecated some time before Release 1.2 |
|
|
1300 |
*/ |
|
1
|
1301 |
function tableInfo($mode = null) |
|
|
1302 |
{ |
|
4
|
1303 |
if (is_string($mode)) { |
|
|
1304 |
return $this->dbh->raiseError(DB_ERROR_NEED_MORE_DATA); |
|
|
1305 |
} |
|
|
1306 |
return $this->dbh->tableInfo($this, $mode); |
|
1
|
1307 |
} |
|
|
1308 |
|
|
4
|
1309 |
// }}} |
|
|
1310 |
// {{{ getQuery() |
|
|
1311 |
|
|
1
|
1312 |
/** |
|
4
|
1313 |
* Determine the query string that created this result |
|
|
1314 |
* |
|
|
1315 |
* @return string the query string |
|
|
1316 |
* |
|
|
1317 |
* @since Method available since Release 1.7.0 |
|
|
1318 |
*/ |
|
|
1319 |
function getQuery() |
|
|
1320 |
{ |
|
|
1321 |
return $this->query; |
|
|
1322 |
} |
|
|
1323 |
|
|
|
1324 |
// }}} |
|
|
1325 |
// {{{ getRowCounter() |
|
|
1326 |
|
|
|
1327 |
/** |
|
|
1328 |
* Tells which row number is currently being processed |
|
|
1329 |
* |
|
|
1330 |
* @return integer the current row being looked at. Starts at 1. |
|
|
1331 |
*/ |
|
1
|
1332 |
function getRowCounter() |
|
|
1333 |
{ |
|
|
1334 |
return $this->row_counter; |
|
|
1335 |
} |
|
4
|
1336 |
|
|
|
1337 |
// }}} |
|
1
|
1338 |
} |
|
|
1339 |
|
|
4
|
1340 |
// }}} |
|
|
1341 |
// {{{ class DB_row |
|
|
1342 |
|
|
1
|
1343 |
/** |
|
4
|
1344 |
* PEAR DB Row Object |
|
|
1345 |
* |
|
|
1346 |
* The object contains a row of data from a result set. Each column's data |
|
|
1347 |
* is placed in a property named for the column. |
|
|
1348 |
* |
|
|
1349 |
* @category Database |
|
|
1350 |
* @package DB |
|
|
1351 |
* @author Stig Bakken <ssb@php.net> |
|
|
1352 |
* @copyright 1997-2005 The PHP Group |
|
|
1353 |
* @license http://www.php.net/license/3_0.txt PHP License 3.0 |
|
|
1354 |
* @version Release: @package_version@ |
|
|
1355 |
* @link http://pear.php.net/package/DB |
|
|
1356 |
* @see DB_common::setFetchMode() |
|
|
1357 |
*/ |
|
1
|
1358 |
class DB_row |
|
|
1359 |
{ |
|
4
|
1360 |
// {{{ constructor |
|
|
1361 |
|
|
1
|
1362 |
/** |
|
4
|
1363 |
* The constructor places a row's data into properties of this object |
|
|
1364 |
* |
|
|
1365 |
* @param array the array containing the row's data |
|
|
1366 |
* |
|
|
1367 |
* @return void |
|
|
1368 |
*/ |
|
1
|
1369 |
function DB_row(&$arr) |
|
|
1370 |
{ |
|
4
|
1371 |
foreach ($arr as $key => $value) { |
|
1
|
1372 |
$this->$key = &$arr[$key]; |
|
|
1373 |
} |
|
|
1374 |
} |
|
4
|
1375 |
|
|
|
1376 |
// }}} |
|
1
|
1377 |
} |
|
|
1378 |
|
|
4
|
1379 |
// }}} |
|
|
1380 |
|
|
|
1381 |
/* |
|
|
1382 |
* Local variables: |
|
|
1383 |
* tab-width: 4 |
|
|
1384 |
* c-basic-offset: 4 |
|
|
1385 |
* End: |
|
|
1386 |
*/ |
|
|
1387 |
|
|
1
|
1388 |
?> |