]> git.mxchange.org Git - quix0rs-gnu-social.git/blob - extlib/DB.php
Notice getRendered() can now be called on uninserted notices
[quix0rs-gnu-social.git] / extlib / DB.php
1 <?php
2
3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
4
5 /**
6  * Database independent query interface
7  *
8  * PHP version 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-2007 The PHP Group
22  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
23  * @version    CVS: $Id$
24  * @link       http://pear.php.net/package/DB
25  */
26
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()
39  *
40  * {@internal If you add an error code here, make sure you also add a textual
41  * version of it in DB::errorMessage().}}
42  */
43
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);
118
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()
193  */
194
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);
201
202 /**
203  * Indicates an opaque (<kbd>&</kbd>) placeholder was used
204  *
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.
225  */
226
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);
236
237 /**
238  * Converts the data to hex format before returning it
239  *
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()
253  */
254
255 /**
256  * Indicates the current default fetch mode should be used
257  * @see DB_common::$fetchmode
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 /**
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.
282  */
283 define('DB_FETCHMODE_FLIPPED', 4);
284 /**#@-*/
285
286 /**#@+
287  * Old fetch modes.  Left here for compatibility.
288  */
289 define('DB_GETMODE_ORDERED', DB_FETCHMODE_ORDERED);
290 define('DB_GETMODE_ASSOC',   DB_FETCHMODE_ASSOC);
291 define('DB_GETMODE_FLIPPED', DB_FETCHMODE_FLIPPED);
292 /**#@-*/
293
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.}}
309  */
310 define('DB_TABLEINFO_ORDER', 1);
311 define('DB_TABLEINFO_ORDERTABLE', 2);
312 define('DB_TABLEINFO_FULL', 3);
313 /**#@-*/
314
315
316 /**#@+
317  * The type of query to create with the automatic query building methods.
318  * @see DB_common::autoPrepare(), DB_common::autoExecute()
319  */
320 define('DB_AUTOQUERY_INSERT', 1);
321 define('DB_AUTOQUERY_UPDATE', 2);
322 /**#@-*/
323
324
325 // }}}
326 // {{{ portability modes
327
328
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
341 /**
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  *
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):
406  * <pre>
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.
420  * </pre>
421  *
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-2007 The PHP Group
428  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
429  * @version    Release: 1.8.2
430  * @link       http://pear.php.net/package/DB
431  */
432 class DB
433 {
434     // {{{ factory()
435
436     /**
437      * Create a new DB object for the specified database type but don't
438      * connect to the database
439      *
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.
444      *
445      * @see DB_common::setOption()
446      */
447     public static function factory($type, $options = false)
448     {
449         if (!is_array($options)) {
450             $options = array('persistent' => $options);
451         }
452
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         }
459
460         $classname = "DB_${type}";
461
462         if (!class_exists($classname)) {
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;
468         }
469
470         @$obj = new $classname;
471
472         foreach ($options as $option => $value) {
473             $test = $obj->setOption($option, $value);
474             if (DB::isError($test)) {
475                 return $test;
476             }
477         }
478
479         return $obj;
480     }
481
482     // }}}
483     // {{{ connect()
484
485     /**
486      * Create a new DB object including a connection to the specified database
487      *
488      * Example 1.
489      * <code>
490      * require_once 'DB.php';
491      *
492      * $dsn = 'pgsql://user:password@host/database';
493      * $options = array(
494      *     'debug'       => 2,
495      *     'portability' => DB_PORTABILITY_ALL,
496      * );
497      *
498      * $db = DB::connect($dsn, $options);
499      * if (PEAR::isError($db)) {
500      *     die($db->getMessage());
501      * }
502      * </code>
503      *
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.
509      *
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()
517      */
518     public static function connect($dsn, $options = array())
519     {
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);
529         }
530
531         if (isset($options['debug']) && $options['debug'] >= 2) {
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)) {
540             $tmp = PEAR::raiseError(null, DB_ERROR_NOT_FOUND, null, null,
541                                     "Unable to include the DB/{$type}.php"
542                                     . " file for '"
543                                     . DB::getDSNString($dsn, true) . "'",
544                                     'DB_Error', true);
545             return $tmp;
546         }
547
548         @$obj = new $classname;
549
550         foreach ($options as $option => $value) {
551             $test = $obj->setOption($option, $value);
552             if (DB::isError($test)) {
553                 return $test;
554             }
555         }
556
557         $err = $obj->connect($dsninfo, $obj->getOption('persistent'));
558         if (DB::isError($err)) {
559             if (is_array($dsn)) {
560                 $err->addUserInfo(DB::getDSNString($dsn, true));
561             } else {
562                 $err->addUserInfo($dsn);
563             }
564             return $err;
565         }
566
567         return $obj;
568     }
569
570     // }}}
571     // {{{ apiVersion()
572
573     /**
574      * Return the DB API version
575      *
576      * @return string  the DB API version number
577      */
578     function apiVersion()
579     {
580         return '1.8.2';
581     }
582
583     // }}}
584     // {{{ isError()
585
586     /**
587      * Determines if a variable is a DB_Error object
588      *
589      * @param mixed $value  the variable to check
590      *
591      * @return bool  whether $value is DB_Error object
592      */
593     public static function isError($value)
594     {
595         return is_object($value) && is_a($value, 'DB_Error');           
596     }
597
598     // }}}
599     // {{{ isConnection()
600
601     /**
602      * Determines if a value is a DB_<driver> object
603      *
604      * @param mixed $value  the value to test
605      *
606      * @return bool  whether $value is a DB_<driver> object
607      */
608     public static function isConnection($value)
609     {
610         return (is_object($value) &&
611                 is_subclass_of($value, 'db_common') &&
612                 method_exists($value, 'simpleQuery'));
613     }
614
615     // }}}
616     // {{{ isManip()
617
618     /**
619      * Tell whether a query is a data manipulation or data definition query
620      *
621      * Examples of data manipulation queries are INSERT, UPDATE and DELETE.
622      * Examples of data definition queries are CREATE, DROP, ALTER, GRANT,
623      * REVOKE.
624      *
625      * @param string $query  the query
626      *
627      * @return boolean  whether $query is a data manipulation query
628      */
629     public static function isManip($query)
630     {
631         $manips = 'INSERT|UPDATE|DELETE|REPLACE|'
632                 . 'CREATE|DROP|'
633                 . 'LOAD DATA|SELECT .* INTO .* FROM|COPY|'
634                 . 'ALTER|GRANT|REVOKE|'
635                 . 'LOCK|UNLOCK';
636         if (preg_match('/^\s*"?(' . $manips . ')\s+/i', $query)) {
637             return true;
638         }
639         return false;
640     }
641
642     // }}}
643     // {{{ errorMessage()
644
645     /**
646      * Return a textual error message for a DB error code
647      *
648      * @param integer $value  the DB error code
649      *
650      * @return string  the error message or false if the error code was
651      *                  not recognized
652      */
653     public static function errorMessage($value)
654     {
655         static $errorMessages;
656         if (!isset($errorMessages)) {
657             $errorMessages = array(
658                 DB_ERROR                    => 'unknown error',
659                 DB_ERROR_ACCESS_VIOLATION   => 'insufficient permissions',
660                 DB_ERROR_ALREADY_EXISTS     => 'already exists',
661                 DB_ERROR_CANNOT_CREATE      => 'can not create',
662                 DB_ERROR_CANNOT_DROP        => 'can not drop',
663                 DB_ERROR_CONNECT_FAILED     => 'connect failed',
664                 DB_ERROR_CONSTRAINT         => 'constraint violation',
665                 DB_ERROR_CONSTRAINT_NOT_NULL=> 'null value violates not-null constraint',
666                 DB_ERROR_DIVZERO            => 'division by zero',
667                 DB_ERROR_EXTENSION_NOT_FOUND=> 'extension not found',
668                 DB_ERROR_INVALID            => 'invalid',
669                 DB_ERROR_INVALID_DATE       => 'invalid date or time',
670                 DB_ERROR_INVALID_DSN        => 'invalid DSN',
671                 DB_ERROR_INVALID_NUMBER     => 'invalid number',
672                 DB_ERROR_MISMATCH           => 'mismatch',
673                 DB_ERROR_NEED_MORE_DATA     => 'insufficient data supplied',
674                 DB_ERROR_NODBSELECTED       => 'no database selected',
675                 DB_ERROR_NOSUCHDB           => 'no such database',
676                 DB_ERROR_NOSUCHFIELD        => 'no such field',
677                 DB_ERROR_NOSUCHTABLE        => 'no such table',
678                 DB_ERROR_NOT_CAPABLE        => 'DB backend not capable',
679                 DB_ERROR_NOT_FOUND          => 'not found',
680                 DB_ERROR_NOT_LOCKED         => 'not locked',
681                 DB_ERROR_SYNTAX             => 'syntax error',
682                 DB_ERROR_UNSUPPORTED        => 'not supported',
683                 DB_ERROR_TRUNCATED          => 'truncated',
684                 DB_ERROR_VALUE_COUNT_ON_ROW => 'value count on row',
685                 DB_OK                       => 'no error',
686             );
687         }
688
689         if (DB::isError($value)) {
690             $value = $value->getCode();
691         }
692
693         return isset($errorMessages[$value]) ? $errorMessages[$value]
694                      : $errorMessages[DB_ERROR];
695     }
696
697     // }}}
698     // {{{ parseDSN()
699
700     /**
701      * Parse a data source name
702      *
703      * Additional keys can be added by appending a URI query string to the
704      * end of the DSN.
705      *
706      * The format of the supplied DSN is in its fullest form:
707      * <code>
708      *  phptype(dbsyntax)://username:password@protocol+hostspec/database?option=8&another=true
709      * </code>
710      *
711      * Most variations are allowed:
712      * <code>
713      *  phptype://username:password@protocol+hostspec:110//usr/db_file.db?mode=0644
714      *  phptype://username:password@hostspec/database_name
715      *  phptype://username:password@hostspec
716      *  phptype://username@hostspec
717      *  phptype://hostspec/database
718      *  phptype://hostspec
719      *  phptype(dbsyntax)
720      *  phptype
721      * </code>
722      *
723      * @param string $dsn Data Source Name to be parsed
724      *
725      * @return array an associative array with the following keys:
726      *  + phptype:  Database backend used in PHP (mysql, odbc etc.)
727      *  + dbsyntax: Database used with regards to SQL syntax etc.
728      *  + protocol: Communication protocol to use (tcp, unix etc.)
729      *  + hostspec: Host specification (hostname[:port])
730      *  + database: Database to use on the DBMS server
731      *  + username: User name for login
732      *  + password: Password for login
733      */
734     public static function parseDSN($dsn)
735     {
736         $parsed = array(
737             'phptype'  => false,
738             'dbsyntax' => false,
739             'username' => false,
740             'password' => false,
741             'protocol' => false,
742             'hostspec' => false,
743             'port'     => false,
744             'socket'   => false,
745             'database' => false,
746         );
747
748         if (is_array($dsn)) {
749             $dsn = array_merge($parsed, $dsn);
750             if (!$dsn['dbsyntax']) {
751                 $dsn['dbsyntax'] = $dsn['phptype'];
752             }
753             return $dsn;
754         }
755
756         // Find phptype and dbsyntax
757         if (($pos = strpos($dsn, '://')) !== false) {
758             $str = substr($dsn, 0, $pos);
759             $dsn = substr($dsn, $pos + 3);
760         } else {
761             $str = $dsn;
762             $dsn = null;
763         }
764
765         // Get phptype and dbsyntax
766         // $str => phptype(dbsyntax)
767         if (preg_match('|^(.+?)\((.*?)\)$|', $str, $arr)) {
768             $parsed['phptype']  = $arr[1];
769             $parsed['dbsyntax'] = !$arr[2] ? $arr[1] : $arr[2];
770         } else {
771             $parsed['phptype']  = $str;
772             $parsed['dbsyntax'] = $str;
773         }
774
775         if (!count($dsn)) {
776             return $parsed;
777         }
778
779         // Get (if found): username and password
780         // $dsn => username:password@protocol+hostspec/database
781         if (($at = strrpos($dsn,'@')) !== false) {
782             $str = substr($dsn, 0, $at);
783             $dsn = substr($dsn, $at + 1);
784             if (($pos = strpos($str, ':')) !== false) {
785                 $parsed['username'] = rawurldecode(substr($str, 0, $pos));
786                 $parsed['password'] = rawurldecode(substr($str, $pos + 1));
787             } else {
788                 $parsed['username'] = rawurldecode($str);
789             }
790         }
791
792         // Find protocol and hostspec
793
794         if (preg_match('|^([^(]+)\((.*?)\)/?(.*?)$|', $dsn, $match)) {
795             // $dsn => proto(proto_opts)/database
796             $proto       = $match[1];
797             $proto_opts  = $match[2] ? $match[2] : false;
798             $dsn         = $match[3];
799
800         } else {
801             // $dsn => protocol+hostspec/database (old format)
802             if (strpos($dsn, '+') !== false) {
803                 list($proto, $dsn) = explode('+', $dsn, 2);
804             }
805             if (strpos($dsn, '/') !== false) {
806                 list($proto_opts, $dsn) = explode('/', $dsn, 2);
807             } else {
808                 $proto_opts = $dsn;
809                 $dsn = null;
810             }
811         }
812
813         // process the different protocol options
814         $parsed['protocol'] = (!empty($proto)) ? $proto : 'tcp';
815         $proto_opts = rawurldecode($proto_opts);
816         if (strpos($proto_opts, ':') !== false) {
817             list($proto_opts, $parsed['port']) = explode(':', $proto_opts);
818         }
819         if ($parsed['protocol'] == 'tcp') {
820             $parsed['hostspec'] = $proto_opts;
821         } elseif ($parsed['protocol'] == 'unix') {
822             $parsed['socket'] = $proto_opts;
823         }
824
825         // Get dabase if any
826         // $dsn => database
827         if ($dsn) {
828             if (($pos = strpos($dsn, '?')) === false) {
829                 // /database
830                 $parsed['database'] = rawurldecode($dsn);
831             } else {
832                 // /database?param1=value1&param2=value2
833                 $parsed['database'] = rawurldecode(substr($dsn, 0, $pos));
834                 $dsn = substr($dsn, $pos + 1);
835                 if (strpos($dsn, '&') !== false) {
836                     $opts = explode('&', $dsn);
837                 } else { // database?param1=value1
838                     $opts = array($dsn);
839                 }
840                 foreach ($opts as $opt) {
841                     list($key, $value) = explode('=', $opt);
842                     if (!isset($parsed[$key])) {
843                         // don't allow params overwrite
844                         $parsed[$key] = rawurldecode($value);
845                     }
846                 }
847             }
848         }
849
850         return $parsed;
851     }
852
853     // }}}
854     // {{{ getDSNString()
855
856     /**
857      * Returns the given DSN in a string format suitable for output.
858      *
859      * @param array|string the DSN to parse and format
860      * @param boolean true to hide the password, false to include it
861      * @return string
862      */
863     public static function getDSNString($dsn, $hidePassword) {
864         /* Calling parseDSN will ensure that we have all the array elements
865          * defined, and means that we deal with strings and array in the same
866          * manner. */
867         $dsnArray = DB::parseDSN($dsn);
868         
869         if ($hidePassword) {
870             $dsnArray['password'] = 'PASSWORD';
871         }
872
873         /* Protocol is special-cased, as using the default "tcp" along with an
874          * Oracle TNS connection string fails. */
875         if (is_string($dsn) && strpos($dsn, 'tcp') === false && $dsnArray['protocol'] == 'tcp') {
876             $dsnArray['protocol'] = false;
877         }
878         
879         // Now we just have to construct the actual string. This is ugly.
880         $dsnString = $dsnArray['phptype'];
881         if ($dsnArray['dbsyntax']) {
882             $dsnString .= '('.$dsnArray['dbsyntax'].')';
883         }
884         $dsnString .= '://'
885                      .$dsnArray['username']
886                      .':'
887                      .$dsnArray['password']
888                      .'@'
889                      .$dsnArray['protocol'];
890         if ($dsnArray['socket']) {
891             $dsnString .= '('.$dsnArray['socket'].')';
892         }
893         if ($dsnArray['protocol'] && $dsnArray['hostspec']) {
894             $dsnString .= '+';
895         }
896         $dsnString .= $dsnArray['hostspec'];
897         if ($dsnArray['port']) {
898             $dsnString .= ':'.$dsnArray['port'];
899         }
900         $dsnString .= '/'.$dsnArray['database'];
901         
902         /* Option handling. Unfortunately, parseDSN simply places options into
903          * the top-level array, so we'll first get rid of the fields defined by
904          * DB and see what's left. */
905         unset($dsnArray['phptype'],
906               $dsnArray['dbsyntax'],
907               $dsnArray['username'],
908               $dsnArray['password'],
909               $dsnArray['protocol'],
910               $dsnArray['socket'],
911               $dsnArray['hostspec'],
912               $dsnArray['port'],
913               $dsnArray['database']
914         );
915         if (count($dsnArray) > 0) {
916             $dsnString .= '?';
917             $i = 0;
918             foreach ($dsnArray as $key => $value) {
919                 if (++$i > 1) {
920                     $dsnString .= '&';
921                 }
922                 $dsnString .= $key.'='.$value;
923             }
924         }
925
926         return $dsnString;
927     }
928     
929     // }}}
930 }
931
932 // }}}
933 // {{{ class DB_Error
934
935 /**
936  * DB_Error implements a class for reporting portable database error
937  * messages
938  *
939  * @category   Database
940  * @package    DB
941  * @author     Stig Bakken <ssb@php.net>
942  * @copyright  1997-2007 The PHP Group
943  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
944  * @version    Release: 1.8.2
945  * @link       http://pear.php.net/package/DB
946  */
947 class DB_Error extends PEAR_Error
948 {
949     // {{{ constructor
950
951     /**
952      * DB_Error constructor
953      *
954      * @param mixed $code       DB error code, or string with error message
955      * @param int   $mode       what "error mode" to operate in
956      * @param int   $level      what error level to use for $mode &
957      *                           PEAR_ERROR_TRIGGER
958      * @param mixed $debuginfo  additional debug info, such as the last query
959      *
960      * @see PEAR_Error
961      */
962     function DB_Error($code = DB_ERROR, $mode = PEAR_ERROR_RETURN,
963                       $level = E_USER_NOTICE, $debuginfo = null)
964     {
965         if (is_int($code)) {
966             $this->PEAR_Error('DB Error: ' . DB::errorMessage($code), $code,
967                               $mode, $level, $debuginfo);
968         } else {
969             $this->PEAR_Error("DB Error: $code", DB_ERROR,
970                               $mode, $level, $debuginfo);
971         }
972     }
973
974     // }}}
975 }
976
977 // }}}
978 // {{{ class DB_result
979
980 /**
981  * This class implements a wrapper for a DB result set
982  *
983  * A new instance of this class will be returned by the DB implementation
984  * after processing a query that returns data.
985  *
986  * @category   Database
987  * @package    DB
988  * @author     Stig Bakken <ssb@php.net>
989  * @copyright  1997-2007 The PHP Group
990  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
991  * @version    Release: 1.8.2
992  * @link       http://pear.php.net/package/DB
993  */
994 class DB_result
995 {
996     // {{{ properties
997
998     /**
999      * Should results be freed automatically when there are no more rows?
1000      * @var boolean
1001      * @see DB_common::$options
1002      */
1003     var $autofree;
1004
1005     /**
1006      * A reference to the DB_<driver> object
1007      * @var object
1008      */
1009     var $dbh;
1010
1011     /**
1012      * The current default fetch mode
1013      * @var integer
1014      * @see DB_common::$fetchmode
1015      */
1016     var $fetchmode;
1017
1018     /**
1019      * The name of the class into which results should be fetched when
1020      * DB_FETCHMODE_OBJECT is in effect
1021      *
1022      * @var string
1023      * @see DB_common::$fetchmode_object_class
1024      */
1025     var $fetchmode_object_class;
1026
1027     /**
1028      * The number of rows to fetch from a limit query
1029      * @var integer
1030      */
1031     var $limit_count = null;
1032
1033     /**
1034      * The row to start fetching from in limit queries
1035      * @var integer
1036      */
1037     var $limit_from = null;
1038
1039     /**
1040      * The execute parameters that created this result
1041      * @var array
1042      * @since Property available since Release 1.7.0
1043      */
1044     var $parameters;
1045
1046     /**
1047      * The query string that created this result
1048      *
1049      * Copied here incase it changes in $dbh, which is referenced
1050      *
1051      * @var string
1052      * @since Property available since Release 1.7.0
1053      */
1054     var $query;
1055
1056     /**
1057      * The query result resource id created by PHP
1058      * @var resource
1059      */
1060     var $result;
1061
1062     /**
1063      * The present row being dealt with
1064      * @var integer
1065      */
1066     var $row_counter = null;
1067
1068     /**
1069      * The prepared statement resource id created by PHP in $dbh
1070      *
1071      * This resource is only available when the result set was created using
1072      * a driver's native execute() method, not PEAR DB's emulated one.
1073      *
1074      * Copied here incase it changes in $dbh, which is referenced
1075      *
1076      * {@internal  Mainly here because the InterBase/Firebird API is only
1077      * able to retrieve data from result sets if the statemnt handle is
1078      * still in scope.}}
1079      *
1080      * @var resource
1081      * @since Property available since Release 1.7.0
1082      */
1083     var $statement;
1084
1085
1086     // }}}
1087     // {{{ constructor
1088
1089     /**
1090      * This constructor sets the object's properties
1091      *
1092      * @param object   &$dbh     the DB object reference
1093      * @param resource $result   the result resource id
1094      * @param array    $options  an associative array with result options
1095      *
1096      * @return void
1097      */
1098     function DB_result(&$dbh, $result, $options = array())
1099     {
1100         $this->autofree    = $dbh->options['autofree'];
1101         $this->dbh         = &$dbh;
1102         $this->fetchmode   = $dbh->fetchmode;
1103         $this->fetchmode_object_class = $dbh->fetchmode_object_class;
1104         $this->parameters  = $dbh->last_parameters;
1105         $this->query       = $dbh->last_query;
1106         $this->result      = $result;
1107         $this->statement   = empty($dbh->last_stmt) ? null : $dbh->last_stmt;
1108         foreach ($options as $key => $value) {
1109             $this->setOption($key, $value);
1110         }
1111     }
1112
1113     /**
1114      * Set options for the DB_result object
1115      *
1116      * @param string $key    the option to set
1117      * @param mixed  $value  the value to set the option to
1118      *
1119      * @return void
1120      */
1121     function setOption($key, $value = null)
1122     {
1123         switch ($key) {
1124             case 'limit_from':
1125                 $this->limit_from = $value;
1126                 break;
1127             case 'limit_count':
1128                 $this->limit_count = $value;
1129         }
1130     }
1131
1132     // }}}
1133     // {{{ fetchRow()
1134
1135     /**
1136      * Fetch a row of data and return it by reference into an array
1137      *
1138      * The type of array returned can be controlled either by setting this
1139      * method's <var>$fetchmode</var> parameter or by changing the default
1140      * fetch mode setFetchMode() before calling this method.
1141      *
1142      * There are two options for standardizing the information returned
1143      * from databases, ensuring their values are consistent when changing
1144      * DBMS's.  These portability options can be turned on when creating a
1145      * new DB object or by using setOption().
1146      *
1147      *   + <var>DB_PORTABILITY_LOWERCASE</var>
1148      *     convert names of fields to lower case
1149      *
1150      *   + <var>DB_PORTABILITY_RTRIM</var>
1151      *     right trim the data
1152      *
1153      * @param int $fetchmode  the constant indicating how to format the data
1154      * @param int $rownum     the row number to fetch (index starts at 0)
1155      *
1156      * @return mixed  an array or object containing the row's data,
1157      *                 NULL when the end of the result set is reached
1158      *                 or a DB_Error object on failure.
1159      *
1160      * @see DB_common::setOption(), DB_common::setFetchMode()
1161      */
1162     function &fetchRow($fetchmode = DB_FETCHMODE_DEFAULT, $rownum = null)
1163     {
1164         if ($fetchmode === DB_FETCHMODE_DEFAULT) {
1165             $fetchmode = $this->fetchmode;
1166         }
1167         if ($fetchmode === DB_FETCHMODE_OBJECT) {
1168             $fetchmode = DB_FETCHMODE_ASSOC;
1169             $object_class = $this->fetchmode_object_class;
1170         }
1171         if (is_null($rownum) && $this->limit_from !== null) {
1172             if ($this->row_counter === null) {
1173                 $this->row_counter = $this->limit_from;
1174                 // Skip rows
1175                 if ($this->dbh->features['limit'] === false) {
1176                     $i = 0;
1177                     while ($i++ < $this->limit_from) {
1178                         $this->dbh->fetchInto($this->result, $arr, $fetchmode);
1179                     }
1180                 }
1181             }
1182             if ($this->row_counter >= ($this->limit_from + $this->limit_count))
1183             {
1184                 if ($this->autofree) {
1185                     $this->free();
1186                 }
1187                 $tmp = null;
1188                 return $tmp;
1189             }
1190             if ($this->dbh->features['limit'] === 'emulate') {
1191                 $rownum = $this->row_counter;
1192             }
1193             $this->row_counter++;
1194         }
1195         $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);
1196         if ($res === DB_OK) {
1197             if (isset($object_class)) {
1198                 // The default mode is specified in the
1199                 // DB_common::fetchmode_object_class property
1200                 if ($object_class == 'stdClass') {
1201                     $arr = (object) $arr;
1202                 } else {
1203                     $arr = new $object_class($arr);
1204                 }
1205             }
1206             return $arr;
1207         }
1208         if ($res == null && $this->autofree) {
1209             $this->free();
1210         }
1211         return $res;
1212     }
1213
1214     // }}}
1215     // {{{ fetchInto()
1216
1217     /**
1218      * Fetch a row of data into an array which is passed by reference
1219      *
1220      * The type of array returned can be controlled either by setting this
1221      * method's <var>$fetchmode</var> parameter or by changing the default
1222      * fetch mode setFetchMode() before calling this method.
1223      *
1224      * There are two options for standardizing the information returned
1225      * from databases, ensuring their values are consistent when changing
1226      * DBMS's.  These portability options can be turned on when creating a
1227      * new DB object or by using setOption().
1228      *
1229      *   + <var>DB_PORTABILITY_LOWERCASE</var>
1230      *     convert names of fields to lower case
1231      *
1232      *   + <var>DB_PORTABILITY_RTRIM</var>
1233      *     right trim the data
1234      *
1235      * @param array &$arr       the variable where the data should be placed
1236      * @param int   $fetchmode  the constant indicating how to format the data
1237      * @param int   $rownum     the row number to fetch (index starts at 0)
1238      *
1239      * @return mixed  DB_OK if a row is processed, NULL when the end of the
1240      *                 result set is reached or a DB_Error object on failure
1241      *
1242      * @see DB_common::setOption(), DB_common::setFetchMode()
1243      */
1244     function fetchInto(&$arr, $fetchmode = DB_FETCHMODE_DEFAULT, $rownum = null)
1245     {
1246         if ($fetchmode === DB_FETCHMODE_DEFAULT) {
1247             $fetchmode = $this->fetchmode;
1248         }
1249         if ($fetchmode === DB_FETCHMODE_OBJECT) {
1250             $fetchmode = DB_FETCHMODE_ASSOC;
1251             $object_class = $this->fetchmode_object_class;
1252         }
1253         if (is_null($rownum) && $this->limit_from !== null) {
1254             if ($this->row_counter === null) {
1255                 $this->row_counter = $this->limit_from;
1256                 // Skip rows
1257                 if ($this->dbh->features['limit'] === false) {
1258                     $i = 0;
1259                     while ($i++ < $this->limit_from) {
1260                         $this->dbh->fetchInto($this->result, $arr, $fetchmode);
1261                     }
1262                 }
1263             }
1264             if ($this->row_counter >= (
1265                     $this->limit_from + $this->limit_count))
1266             {
1267                 if ($this->autofree) {
1268                     $this->free();
1269                 }
1270                 return null;
1271             }
1272             if ($this->dbh->features['limit'] === 'emulate') {
1273                 $rownum = $this->row_counter;
1274             }
1275
1276             $this->row_counter++;
1277         }
1278         $res = $this->dbh->fetchInto($this->result, $arr, $fetchmode, $rownum);
1279         if ($res === DB_OK) {
1280             if (isset($object_class)) {
1281                 // default mode specified in the
1282                 // DB_common::fetchmode_object_class property
1283                 if ($object_class == 'stdClass') {
1284                     $arr = (object) $arr;
1285                 } else {
1286                     $arr = new $object_class($arr);
1287                 }
1288             }
1289             return DB_OK;
1290         }
1291         if ($res == null && $this->autofree) {
1292             $this->free();
1293         }
1294         return $res;
1295     }
1296
1297     // }}}
1298     // {{{ numCols()
1299
1300     /**
1301      * Get the the number of columns in a result set
1302      *
1303      * @return int  the number of columns.  A DB_Error object on failure.
1304      */
1305     function numCols()
1306     {
1307         return $this->dbh->numCols($this->result);
1308     }
1309
1310     // }}}
1311     // {{{ numRows()
1312
1313     /**
1314      * Get the number of rows in a result set
1315      *
1316      * @return int  the number of rows.  A DB_Error object on failure.
1317      */
1318     function numRows()
1319     {
1320         if ($this->dbh->features['numrows'] === 'emulate'
1321             && $this->dbh->options['portability'] & DB_PORTABILITY_NUMROWS)
1322         {
1323             if ($this->dbh->features['prepare']) {
1324                 $res = $this->dbh->query($this->query, $this->parameters);
1325             } else {
1326                 $res = $this->dbh->query($this->query);
1327             }
1328             if (DB::isError($res)) {
1329                 return $res;
1330             }
1331             $i = 0;
1332             while ($res->fetchInto($tmp, DB_FETCHMODE_ORDERED)) {
1333                 $i++;
1334             }
1335             $count = $i;
1336         } else {
1337             $count = $this->dbh->numRows($this->result);
1338         }
1339
1340         /* fbsql is checked for here because limit queries are implemented
1341          * using a TOP() function, which results in fbsql_num_rows still
1342          * returning the total number of rows that would have been returned,
1343          * rather than the real number. As a result, we'll just do the limit
1344          * calculations for fbsql in the same way as a database with emulated
1345          * limits. Unfortunately, we can't just do this in DB_fbsql::numRows()
1346          * because that only gets the result resource, rather than the full
1347          * DB_Result object. */
1348         if (($this->dbh->features['limit'] === 'emulate'
1349              && $this->limit_from !== null)
1350             || $this->dbh->phptype == 'fbsql') {
1351             $limit_count = is_null($this->limit_count) ? $count : $this->limit_count;
1352             if ($count < $this->limit_from) {
1353                 $count = 0;
1354             } elseif ($count < ($this->limit_from + $limit_count)) {
1355                 $count -= $this->limit_from;
1356             } else {
1357                 $count = $limit_count;
1358             }
1359         }
1360
1361         return $count;
1362     }
1363
1364     // }}}
1365     // {{{ nextResult()
1366
1367     /**
1368      * Get the next result if a batch of queries was executed
1369      *
1370      * @return bool  true if a new result is available or false if not
1371      */
1372     function nextResult()
1373     {
1374         return $this->dbh->nextResult($this->result);
1375     }
1376
1377     // }}}
1378     // {{{ free()
1379
1380     /**
1381      * Frees the resources allocated for this result set
1382      *
1383      * @return bool  true on success.  A DB_Error object on failure.
1384      */
1385     function free()
1386     {
1387         $err = $this->dbh->freeResult($this->result);
1388         if (DB::isError($err)) {
1389             return $err;
1390         }
1391         $this->result = false;
1392         $this->statement = false;
1393         return true;
1394     }
1395
1396     // }}}
1397     // {{{ tableInfo()
1398
1399     /**
1400      * @see DB_common::tableInfo()
1401      * @deprecated Method deprecated some time before Release 1.2
1402      */
1403     function tableInfo($mode = null)
1404     {
1405         if (is_string($mode)) {
1406             return $this->dbh->raiseError(DB_ERROR_NEED_MORE_DATA);
1407         }
1408         return $this->dbh->tableInfo($this, $mode);
1409     }
1410
1411     // }}}
1412     // {{{ getQuery()
1413
1414     /**
1415      * Determine the query string that created this result
1416      *
1417      * @return string  the query string
1418      *
1419      * @since Method available since Release 1.7.0
1420      */
1421     function getQuery()
1422     {
1423         return $this->query;
1424     }
1425
1426     // }}}
1427     // {{{ getRowCounter()
1428
1429     /**
1430      * Tells which row number is currently being processed
1431      *
1432      * @return integer  the current row being looked at.  Starts at 1.
1433      */
1434     function getRowCounter()
1435     {
1436         return $this->row_counter;
1437     }
1438
1439     // }}}
1440 }
1441
1442 // }}}
1443 // {{{ class DB_row
1444
1445 /**
1446  * PEAR DB Row Object
1447  *
1448  * The object contains a row of data from a result set.  Each column's data
1449  * is placed in a property named for the column.
1450  *
1451  * @category   Database
1452  * @package    DB
1453  * @author     Stig Bakken <ssb@php.net>
1454  * @copyright  1997-2007 The PHP Group
1455  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
1456  * @version    Release: 1.8.2
1457  * @link       http://pear.php.net/package/DB
1458  * @see        DB_common::setFetchMode()
1459  */
1460 class DB_row
1461 {
1462     // {{{ constructor
1463
1464     /**
1465      * The constructor places a row's data into properties of this object
1466      *
1467      * @param array  the array containing the row's data
1468      *
1469      * @return void
1470      */
1471     function DB_row(&$arr)
1472     {
1473         foreach ($arr as $key => $value) {
1474             $this->$key = &$arr[$key];
1475         }
1476     }
1477
1478     // }}}
1479 }
1480
1481 // }}}
1482
1483 /*
1484  * Local variables:
1485  * tab-width: 4
1486  * c-basic-offset: 4
1487  * End:
1488  */
1489
1490 ?>