program/lib/DB/msql.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * The PEAR DB driver for PHP's msql extension
   7  * for interacting with Mini SQL databases
   8  *
   9  * PHP's mSQL extension did weird things with NULL values prior to PHP
  10  * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
  11  * those versions.
  12  *
  13  * PHP versions 4 and 5
  14  *
  15  * LICENSE: This source file is subject to version 3.0 of the PHP license
  16  * that is available through the world-wide-web at the following URI:
  17  * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
  18  * the PHP License and are unable to obtain it through the web, please
  19  * send a note to license@php.net so we can mail you a copy immediately.
  20  *
  21  * @category   Database
  22  * @package    DB
  23  * @author     Daniel Convissor <danielc@php.net>
  24  * @copyright  1997-2005 The PHP Group
  25  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  26  * @version    CVS: $Id: msql.php 12 2005-10-02 11:36:35Z sparc $
  27  * @link       http://pear.php.net/package/DB
  28  */
  29
  30 /**
  31  * Obtain the DB_common class so it can be extended from
  32  */
  33 require_once 'DB/common.php';
  34
  35 /**
  36  * The methods PEAR DB uses to interact with PHP's msql extension
  37  * for interacting with Mini SQL databases
  38  *
  39  * These methods overload the ones declared in DB_common.
  40  *
  41  * PHP's mSQL extension did weird things with NULL values prior to PHP
  42  * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
  43  * those versions.
  44  *
  45  * @category   Database
  46  * @package    DB
  47  * @author     Daniel Convissor <danielc@php.net>
  48  * @copyright  1997-2005 The PHP Group
  49  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  50  * @version    Release: @package_version@
  51  * @link       http://pear.php.net/package/DB
  52  * @since      Class not functional until Release 1.7.0
  53  */
  54 class DB_msql extends DB_common
  55 {
  56     // {{{ properties
  57
  58     /**
  59      * The DB driver type (mysql, oci8, odbc, etc.)
  60      * @var string
  61      */
  62     var $phptype = 'msql';
  63
  64     /**
  65      * The database syntax variant to be used (db2, access, etc.), if any
  66      * @var string
  67      */
  68     var $dbsyntax = 'msql';
  69
  70     /**
  71      * The capabilities of this DB implementation
  72      *
  73      * The 'new_link' element contains the PHP version that first provided
  74      * new_link support for this DBMS.  Contains false if it's unsupported.
  75      *
  76      * Meaning of the 'limit' element:
  77      *   + 'emulate' = emulate with fetch row by number
  78      *   + 'alter'   = alter the query
  79      *   + false     = skip rows
  80      *
  81      * @var array
  82      */
  83     var $features = array(
  84         'limit'         => 'emulate',
  85         'new_link'      => false,
  86         'numrows'       => true,
  87         'pconnect'      => true,
  88         'prepare'       => false,
  89         'ssl'           => false,
  90         'transactions'  => false,
  91     );
  92
  93     /**
  94      * A mapping of native error codes to DB error codes
  95      * @var array
  96      */
  97     var $errorcode_map = array(
  98     );
  99
 100     /**
 101      * The raw database connection created by PHP
 102      * @var resource
 103      */
 104     var $connection;
 105
 106     /**
 107      * The DSN information for connecting to a database
 108      * @var array
 109      */
 110     var $dsn = array();
 111
 112
 113     /**
 114      * The query result resource created by PHP
 115      *
 116      * Used to make affectedRows() work.  Only contains the result for
 117      * data manipulation queries.  Contains false for other queries.
 118      *
 119      * @var resource
 120      * @access private
 121      */
 122     var $_result;
 123
 124
 125     // }}}
 126     // {{{ constructor
 127
 128     /**
 129      * This constructor calls <kbd>$this->DB_common()</kbd>
 130      *
 131      * @return void
 132      */
 133     function DB_msql()
 134     {
 135         $this->DB_common();
 136     }
 137
 138     // }}}
 139     // {{{ connect()
 140
 141     /**
 142      * Connect to the database server, log in and open the database
 143      *
 144      * Don't call this method directly.  Use DB::connect() instead.
 145      *
 146      * Example of how to connect:
 147      * <code>
 148      * require_once 'DB.php';
 149      *
 150      * // $dsn = 'msql://hostname/dbname';  // use a TCP connection
 151      * $dsn = 'msql:///dbname';             // use a socket
 152      * $options = array(
 153      *     'portability' => DB_PORTABILITY_ALL,
 154      * );
 155      *
 156      * $db =& DB::connect($dsn, $options);
 157      * if (PEAR::isError($db)) {
 158      *     die($db->getMessage());
 159      * }
 160      * </code>
 161      *
 162      * @param array $dsn         the data source name
 163      * @param bool  $persistent  should the connection be persistent?
 164      *
 165      * @return int  DB_OK on success. A DB_Error object on failure.
 166      */
 167     function connect($dsn, $persistent = false)
 168     {
 169         if (!PEAR::loadExtension('msql')) {
 170             return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
 171         }
 172
 173         $this->dsn = $dsn;
 174         if ($dsn['dbsyntax']) {
 175             $this->dbsyntax = $dsn['dbsyntax'];
 176         }
 177
 178         $params = array();
 179         if ($dsn['hostspec']) {
 180             $params[] = $dsn['port']
 181                         ? $dsn['hostspec'] . ',' . $dsn['port']
 182                         : $dsn['hostspec'];
 183         }
 184
 185         $connect_function = $persistent ? 'msql_pconnect' : 'msql_connect';
 186
 187         $ini = ini_get('track_errors');
 188         $php_errormsg = '';
 189         if ($ini) {
 190             $this->connection = @call_user_func_array($connect_function,
 191                                                       $params);
 192         } else {
 193             ini_set('track_errors', 1);
 194             $this->connection = @call_user_func_array($connect_function,
 195                                                       $params);
 196             ini_set('track_errors', $ini);
 197         }
 198
 199         if (!$this->connection) {
 200             if (($err = @msql_error()) != '') {
 201                 return $this->raiseError(DB_ERROR_CONNECT_FAILED,
 202                                          null, null, null,
 203                                          $err);
 204             } else {
 205                 return $this->raiseError(DB_ERROR_CONNECT_FAILED,
 206                                          null, null, null,
 207                                          $php_errormsg);
 208             }
 209         }
 210
 211         if (!@msql_select_db($dsn['database'], $this->connection)) {
 212             return $this->msqlRaiseError();
 213         }
 214         return DB_OK;
 215     }
 216
 217     // }}}
 218     // {{{ disconnect()
 219
 220     /**
 221      * Disconnects from the database server
 222      *
 223      * @return bool  TRUE on success, FALSE on failure
 224      */
 225     function disconnect()
 226     {
 227         $ret = @msql_close($this->connection);
 228         $this->connection = null;
 229         return $ret;
 230     }
 231
 232     // }}}
 233     // {{{ simpleQuery()
 234
 235     /**
 236      * Sends a query to the database server
 237      *
 238      * @param string  the SQL query string
 239      *
 240      * @return mixed  + a PHP result resrouce for successful SELECT queries
 241      *                + the DB_OK constant for other successful queries
 242      *                + a DB_Error object on failure
 243      */
 244     function simpleQuery($query)
 245     {
 246         $this->last_query = $query;
 247         $query = $this->modifyQuery($query);
 248         $result = @msql_query($query, $this->connection);
 249         if (!$result) {
 250             return $this->msqlRaiseError();
 251         }
 252         // Determine which queries that should return data, and which
 253         // should return an error code only.
 254         if (DB::isManip($query)) {
 255             $this->_result = $result;
 256             return DB_OK;
 257         } else {
 258             $this->_result = false;
 259             return $result;
 260         }
 261     }
 262
 263
 264     // }}}
 265     // {{{ nextResult()
 266
 267     /**
 268      * Move the internal msql result pointer to the next available result
 269      *
 270      * @param a valid fbsql result resource
 271      *
 272      * @access public
 273      *
 274      * @return true if a result is available otherwise return false
 275      */
 276     function nextResult($result)
 277     {
 278         return false;
 279     }
 280
 281     // }}}
 282     // {{{ fetchInto()
 283
 284     /**
 285      * Places a row from the result set into the given array
 286      *
 287      * Formating of the array and the data therein are configurable.
 288      * See DB_result::fetchInto() for more information.
 289      *
 290      * This method is not meant to be called directly.  Use
 291      * DB_result::fetchInto() instead.  It can't be declared "protected"
 292      * because DB_result is a separate object.
 293      *
 294      * PHP's mSQL extension did weird things with NULL values prior to PHP
 295      * 4.3.11 and 5.0.4.  Make sure your version of PHP meets or exceeds
 296      * those versions.
 297      *
 298      * @param resource $result    the query result resource
 299      * @param array    $arr       the referenced array to put the data in
 300      * @param int      $fetchmode how the resulting array should be indexed
 301      * @param int      $rownum    the row number to fetch (0 = first row)
 302      *
 303      * @return mixed  DB_OK on success, NULL when the end of a result set is
 304      *                 reached or on failure
 305      *
 306      * @see DB_result::fetchInto()
 307      */
 308     function fetchInto($result, &$arr, $fetchmode, $rownum = null)
 309     {
 310         if ($rownum !== null) {
 311             if (!@msql_data_seek($result, $rownum)) {
 312                 return null;
 313             }
 314         }
 315         if ($fetchmode & DB_FETCHMODE_ASSOC) {
 316             $arr = @msql_fetch_array($result, MSQL_ASSOC);
 317             if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
 318                 $arr = array_change_key_case($arr, CASE_LOWER);
 319             }
 320         } else {
 321             $arr = @msql_fetch_row($result);
 322         }
 323         if (!$arr) {
 324             return null;
 325         }
 326         if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
 327             $this->_rtrimArrayValues($arr);
 328         }
 329         if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
 330             $this->_convertNullArrayValuesToEmpty($arr);
 331         }
 332         return DB_OK;
 333     }
 334
 335     // }}}
 336     // {{{ freeResult()
 337
 338     /**
 339      * Deletes the result set and frees the memory occupied by the result set
 340      *
 341      * This method is not meant to be called directly.  Use
 342      * DB_result::free() instead.  It can't be declared "protected"
 343      * because DB_result is a separate object.
 344      *
 345      * @param resource $result  PHP's query result resource
 346      *
 347      * @return bool  TRUE on success, FALSE if $result is invalid
 348      *
 349      * @see DB_result::free()
 350      */
 351     function freeResult($result)
 352     {
 353         return @msql_free_result($result);
 354     }
 355
 356     // }}}
 357     // {{{ numCols()
 358
 359     /**
 360      * Gets the number of columns in a result set
 361      *
 362      * This method is not meant to be called directly.  Use
 363      * DB_result::numCols() instead.  It can't be declared "protected"
 364      * because DB_result is a separate object.
 365      *
 366      * @param resource $result  PHP's query result resource
 367      *
 368      * @return int  the number of columns.  A DB_Error object on failure.
 369      *
 370      * @see DB_result::numCols()
 371      */
 372     function numCols($result)
 373     {
 374         $cols = @msql_num_fields($result);
 375         if (!$cols) {
 376             return $this->msqlRaiseError();
 377         }
 378         return $cols;
 379     }
 380
 381     // }}}
 382     // {{{ numRows()
 383
 384     /**
 385      * Gets the number of rows in a result set
 386      *
 387      * This method is not meant to be called directly.  Use
 388      * DB_result::numRows() instead.  It can't be declared "protected"
 389      * because DB_result is a separate object.
 390      *
 391      * @param resource $result  PHP's query result resource
 392      *
 393      * @return int  the number of rows.  A DB_Error object on failure.
 394      *
 395      * @see DB_result::numRows()
 396      */
 397     function numRows($result)
 398     {
 399         $rows = @msql_num_rows($result);
 400         if ($rows === false) {
 401             return $this->msqlRaiseError();
 402         }
 403         return $rows;
 404     }
 405
 406     // }}}
 407     // {{{ affected()
 408
 409     /**
 410      * Determines the number of rows affected by a data maniuplation query
 411      *
 412      * 0 is returned for queries that don't manipulate data.
 413      *
 414      * @return int  the number of rows.  A DB_Error object on failure.
 415      */
 416     function affectedRows()
 417     {
 418         if (!$this->_result) {
 419             return 0;
 420         }
 421         return msql_affected_rows($this->_result);
 422     }
 423
 424     // }}}
 425     // {{{ nextId()
 426
 427     /**
 428      * Returns the next free id in a sequence
 429      *
 430      * @param string  $seq_name  name of the sequence
 431      * @param boolean $ondemand  when true, the seqence is automatically
 432      *                            created if it does not exist
 433      *
 434      * @return int  the next id number in the sequence.
 435      *               A DB_Error object on failure.
 436      *
 437      * @see DB_common::nextID(), DB_common::getSequenceName(),
 438      *      DB_msql::createSequence(), DB_msql::dropSequence()
 439      */
 440     function nextId($seq_name, $ondemand = true)
 441     {
 442         $seqname = $this->getSequenceName($seq_name);
 443         $repeat = false;
 444         do {
 445             $this->pushErrorHandling(PEAR_ERROR_RETURN);
 446             $result =& $this->query("SELECT _seq FROM ${seqname}");
 447             $this->popErrorHandling();
 448             if ($ondemand && DB::isError($result) &&
 449                 $result->getCode() == DB_ERROR_NOSUCHTABLE) {
 450                 $repeat = true;
 451                 $this->pushErrorHandling(PEAR_ERROR_RETURN);
 452                 $result = $this->createSequence($seq_name);
 453                 $this->popErrorHandling();
 454                 if (DB::isError($result)) {
 455                     return $this->raiseError($result);
 456                 }
 457             } else {
 458                 $repeat = false;
 459             }
 460         } while ($repeat);
 461         if (DB::isError($result)) {
 462             return $this->raiseError($result);
 463         }
 464         $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
 465         $result->free();
 466         return $arr[0];
 467     }
 468
 469     // }}}
 470     // {{{ createSequence()
 471
 472     /**
 473      * Creates a new sequence
 474      *
 475      * Also creates a new table to associate the sequence with.  Uses
 476      * a separate table to ensure portability with other drivers.
 477      *
 478      * @param string $seq_name  name of the new sequence
 479      *
 480      * @return int  DB_OK on success.  A DB_Error object on failure.
 481      *
 482      * @see DB_common::createSequence(), DB_common::getSequenceName(),
 483      *      DB_msql::nextID(), DB_msql::dropSequence()
 484      */
 485     function createSequence($seq_name)
 486     {
 487         $seqname = $this->getSequenceName($seq_name);
 488         $res = $this->query('CREATE TABLE ' . $seqname
 489                             . ' (id INTEGER NOT NULL)');
 490         if (DB::isError($res)) {
 491             return $res;
 492         }
 493         $res = $this->query("CREATE SEQUENCE ON ${seqname}");
 494         return $res;
 495     }
 496
 497     // }}}
 498     // {{{ dropSequence()
 499
 500     /**
 501      * Deletes a sequence
 502      *
 503      * @param string $seq_name  name of the sequence to be deleted
 504      *
 505      * @return int  DB_OK on success.  A DB_Error object on failure.
 506      *
 507      * @see DB_common::dropSequence(), DB_common::getSequenceName(),
 508      *      DB_msql::nextID(), DB_msql::createSequence()
 509      */
 510     function dropSequence($seq_name)
 511     {
 512         return $this->query('DROP TABLE ' . $this->getSequenceName($seq_name));
 513     }
 514
 515     // }}}
 516     // {{{ quoteIdentifier()
 517
 518     /**
 519      * mSQL does not support delimited identifiers
 520      *
 521      * @param string $str  the identifier name to be quoted
 522      *
 523      * @return object  a DB_Error object
 524      *
 525      * @see DB_common::quoteIdentifier()
 526      * @since Method available since Release 1.7.0
 527      */
 528     function quoteIdentifier($str)
 529     {
 530         return $this->raiseError(DB_ERROR_UNSUPPORTED);
 531     }
 532
 533     // }}}
 534     // {{{ escapeSimple()
 535
 536     /**
 537      * Escapes a string according to the current DBMS's standards
 538      *
 539      * @param string $str  the string to be escaped
 540      *
 541      * @return string  the escaped string
 542      *
 543      * @see DB_common::quoteSmart()
 544      * @since Method available since Release 1.7.0
 545      */
 546     function escapeSimple($str)
 547     {
 548         return addslashes($str);
 549     }
 550
 551     // }}}
 552     // {{{ msqlRaiseError()
 553
 554     /**
 555      * Produces a DB_Error object regarding the current problem
 556      *
 557      * @param int $errno  if the error is being manually raised pass a
 558      *                     DB_ERROR* constant here.  If this isn't passed
 559      *                     the error information gathered from the DBMS.
 560      *
 561      * @return object  the DB_Error object
 562      *
 563      * @see DB_common::raiseError(),
 564      *      DB_msql::errorNative(), DB_msql::errorCode()
 565      */
 566     function msqlRaiseError($errno = null)
 567     {
 568         $native = $this->errorNative();
 569         if ($errno === null) {
 570             $errno = $this->errorCode($native);
 571         }
 572         return $this->raiseError($errno, null, null, null, $native);
 573     }
 574
 575     // }}}
 576     // {{{ errorNative()
 577
 578     /**
 579      * Gets the DBMS' native error message produced by the last query
 580      *
 581      * @return string  the DBMS' error message
 582      */
 583     function errorNative()
 584     {
 585         return @msql_error();
 586     }
 587
 588     // }}}
 589     // {{{ errorCode()
 590
 591     /**
 592      * Determines PEAR::DB error code from the database's text error message
 593      *
 594      * @param string $errormsg  the error message returned from the database
 595      *
 596      * @return integer  the error number from a DB_ERROR* constant
 597      */
 598     function errorCode($errormsg)
 599     {
 600         static $error_regexps;
 601         if (!isset($error_regexps)) {
 602             $error_regexps = array(
 603                 '/^Access to database denied/i'
 604                     => DB_ERROR_ACCESS_VIOLATION,
 605                 '/^Bad index name/i'
 606                     => DB_ERROR_ALREADY_EXISTS,
 607                 '/^Bad order field/i'
 608                     => DB_ERROR_SYNTAX,
 609                 '/^Bad type for comparison/i'
 610                     => DB_ERROR_SYNTAX,
 611                 '/^Can\'t perform LIKE on/i'
 612                     => DB_ERROR_SYNTAX,
 613                 '/^Can\'t use TEXT fields in LIKE comparison/i'
 614                     => DB_ERROR_SYNTAX,
 615                 '/^Couldn\'t create temporary table/i'
 616                     => DB_ERROR_CANNOT_CREATE,
 617                 '/^Error creating table file/i'
 618                     => DB_ERROR_CANNOT_CREATE,
 619                 '/^Field .* cannot be null$/i'
 620                     => DB_ERROR_CONSTRAINT_NOT_NULL,
 621                 '/^Index (field|condition) .* cannot be null$/i'
 622                     => DB_ERROR_SYNTAX,
 623                 '/^Invalid date format/i'
 624                     => DB_ERROR_INVALID_DATE,
 625                 '/^Invalid time format/i'
 626                     => DB_ERROR_INVALID,
 627                 '/^Literal value for .* is wrong type$/i'
 628                     => DB_ERROR_INVALID_NUMBER,
 629                 '/^No Database Selected/i'
 630                     => DB_ERROR_NODBSELECTED,
 631                 '/^No value specified for field/i'
 632                     => DB_ERROR_VALUE_COUNT_ON_ROW,
 633                 '/^Non unique value for unique index/i'
 634                     => DB_ERROR_CONSTRAINT,
 635                 '/^Out of memory for temporary table/i'
 636                     => DB_ERROR_CANNOT_CREATE,
 637                 '/^Permission denied/i'
 638                     => DB_ERROR_ACCESS_VIOLATION,
 639                 '/^Reference to un-selected table/i'
 640                     => DB_ERROR_SYNTAX,
 641                 '/^syntax error/i'
 642                     => DB_ERROR_SYNTAX,
 643                 '/^Table .* exists$/i'
 644                     => DB_ERROR_ALREADY_EXISTS,
 645                 '/^Unknown database/i'
 646                     => DB_ERROR_NOSUCHDB,
 647                 '/^Unknown field/i'
 648                     => DB_ERROR_NOSUCHFIELD,
 649                 '/^Unknown (index|system variable)/i'
 650                     => DB_ERROR_NOT_FOUND,
 651                 '/^Unknown table/i'
 652                     => DB_ERROR_NOSUCHTABLE,
 653                 '/^Unqualified field/i'
 654                     => DB_ERROR_SYNTAX,
 655             );
 656         }
 657
 658         foreach ($error_regexps as $regexp => $code) {
 659             if (preg_match($regexp, $errormsg)) {
 660                 return $code;
 661             }
 662         }
 663         return DB_ERROR;
 664     }
 665
 666     // }}}
 667     // {{{ tableInfo()
 668
 669     /**
 670      * Returns information about a table or a result set
 671      *
 672      * @param object|string  $result  DB_result object from a query or a
 673      *                                 string containing the name of a table.
 674      *                                 While this also accepts a query result
 675      *                                 resource identifier, this behavior is
 676      *                                 deprecated.
 677      * @param int            $mode    a valid tableInfo mode
 678      *
 679      * @return array  an associative array with the information requested.
 680      *                 A DB_Error object on failure.
 681      *
 682      * @see DB_common::setOption()
 683      */
 684     function tableInfo($result, $mode = null)
 685     {
 686         if (is_string($result)) {
 687             /*
 688              * Probably received a table name.
 689              * Create a result resource identifier.
 690              */
 691             $id = @msql_query("SELECT * FROM $result",
 692                               $this->connection);
 693             $got_string = true;
 694         } elseif (isset($result->result)) {
 695             /*
 696              * Probably received a result object.
 697              * Extract the result resource identifier.
 698              */
 699             $id = $result->result;
 700             $got_string = false;
 701         } else {
 702             /*
 703              * Probably received a result resource identifier.
 704              * Copy it.
 705              * Deprecated.  Here for compatibility only.
 706              */
 707             $id = $result;
 708             $got_string = false;
 709         }
 710
 711         if (!is_resource($id)) {
 712             return $this->raiseError(DB_ERROR_NEED_MORE_DATA);
 713         }
 714
 715         if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
 716             $case_func = 'strtolower';
 717         } else {
 718             $case_func = 'strval';
 719         }
 720
 721         $count = @msql_num_fields($id);
 722         $res   = array();
 723
 724         if ($mode) {
 725             $res['num_fields'] = $count;
 726         }
 727
 728         for ($i = 0; $i < $count; $i++) {
 729             $tmp = @msql_fetch_field($id);
 730
 731             $flags = '';
 732             if ($tmp->not_null) {
 733                 $flags .= 'not_null ';
 734             }
 735             if ($tmp->unique) {
 736                 $flags .= 'unique_key ';
 737             }
 738             $flags = trim($flags);
 739
 740             $res[$i] = array(
 741                 'table' => $case_func($tmp->table),
 742                 'name'  => $case_func($tmp->name),
 743                 'type'  => $tmp->type,
 744                 'len'   => msql_field_len($id, $i),
 745                 'flags' => $flags,
 746             );
 747
 748             if ($mode & DB_TABLEINFO_ORDER) {
 749                 $res['order'][$res[$i]['name']] = $i;
 750             }
 751             if ($mode & DB_TABLEINFO_ORDERTABLE) {
 752                 $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
 753             }
 754         }
 755
 756         // free the result only if we were called on a table
 757         if ($got_string) {
 758             @msql_free_result($id);
 759         }
 760         return $res;
 761     }
 762
 763     // }}}
 764     // {{{ getSpecialQuery()
 765
 766     /**
 767      * Obtain a list of a given type of objects
 768      *
 769      * @param string $type  the kind of objects you want to retrieve
 770      *
 771      * @return array  the array containing the list of objects requested
 772      *
 773      * @access protected
 774      * @see DB_common::getListOf()
 775      */
 776     function getSpecialQuery($type)
 777     {
 778         switch ($type) {
 779             case 'databases':
 780                 $id = @msql_list_dbs($this->connection);
 781                 break;
 782             case 'tables':
 783                 $id = @msql_list_tables($this->dsn['database'],
 784                                         $this->connection);
 785                 break;
 786             default:
 787                 return null;
 788         }
 789         if (!$id) {
 790             return $this->msqlRaiseError();
 791         }
 792         $out = array();
 793         while ($row = @msql_fetch_row($id)) {
 794             $out[] = $row[0];
 795         }
 796         return $out;
 797     }
 798
 799     // }}}
 800
 801 }
 802
 803 /*
 804  * Local variables:
 805  * tab-width: 4
 806  * c-basic-offset: 4
 807  * End:
 808  */
 809
 810 ?>