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