lib/pear/DB/ibase.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4 foldmethod=marker: */
   3 // +----------------------------------------------------------------------+
   4 // | PHP Version 4                                                        |
   5 // +----------------------------------------------------------------------+
   6 // | Copyright (c) 1997-2004 The PHP Group                                |
   7 // +----------------------------------------------------------------------+
   8 // | This source file is subject to version 2.02 of the PHP license,      |
   9 // | that is bundled with this package in the file LICENSE, and is        |
  10 // | available at through the world-wide-web at                           |
  11 // | http://www.php.net/license/2_02.txt.                                 |
  12 // | If you did not receive a copy of the PHP license and are unable to   |
  13 // | obtain it through the world-wide-web, please send a note to          |
  14 // | license@php.net so we can mail you a copy immediately.               |
  15 // +----------------------------------------------------------------------+
  16 // | Author: Sterling Hughes <sterling@php.net>                           |
  17 // | Maintainer: Daniel Convissor <danielc@php.net>                       |
  18 // +----------------------------------------------------------------------+
  19 //
  20 // $Id$
  21
  22
  23 // Bugs:
  24 //  - If dbsyntax is not firebird, the limitQuery may fail
  25
  26
  27 require_once 'DB/common.php';
  28
  29 /**
  30  * Database independent query interface definition for PHP's Interbase
  31  * extension.
  32  *
  33  * @package  DB
  34  * @version  $Id$
  35  * @category Database
  36  * @author   Sterling Hughes <sterling@php.net>
  37  */
  38 class DB_ibase extends DB_common
  39 {
  40
  41     // {{{ properties
  42
  43     var $connection;
  44     var $phptype, $dbsyntax;
  45     var $autocommit = 1;
  46     var $manip_query = array();
  47
  48     // }}}
  49     // {{{ constructor
  50
  51     function DB_ibase()
  52     {
  53         $this->DB_common();
  54         $this->phptype = 'ibase';
  55         $this->dbsyntax = 'ibase';
  56         $this->features = array(
  57             'prepare' => true,
  58             'pconnect' => true,
  59             'transactions' => true,
  60             'limit' => false
  61         );
  62         // just a few of the tons of Interbase error codes listed in the
  63         // Language Reference section of the Interbase manual
  64         $this->errorcode_map = array(
  65             -104 => DB_ERROR_SYNTAX,
  66             -150 => DB_ERROR_ACCESS_VIOLATION,
  67             -151 => DB_ERROR_ACCESS_VIOLATION,
  68             -155 => DB_ERROR_NOSUCHTABLE,
  69             88   => DB_ERROR_NOSUCHTABLE,
  70             -157 => DB_ERROR_NOSUCHFIELD,
  71             -158 => DB_ERROR_VALUE_COUNT_ON_ROW,
  72             -170 => DB_ERROR_MISMATCH,
  73             -171 => DB_ERROR_MISMATCH,
  74             -172 => DB_ERROR_INVALID,
  75             -204 => DB_ERROR_INVALID,
  76             -205 => DB_ERROR_NOSUCHFIELD,
  77             -206 => DB_ERROR_NOSUCHFIELD,
  78             -208 => DB_ERROR_INVALID,
  79             -219 => DB_ERROR_NOSUCHTABLE,
  80             -297 => DB_ERROR_CONSTRAINT,
  81             -530 => DB_ERROR_CONSTRAINT,
  82             -607 => DB_ERROR_NOSUCHTABLE,
  83             -803 => DB_ERROR_CONSTRAINT,
  84             -551 => DB_ERROR_ACCESS_VIOLATION,
  85             -552 => DB_ERROR_ACCESS_VIOLATION,
  86             -922 => DB_ERROR_NOSUCHDB,
  87             -923 => DB_ERROR_CONNECT_FAILED,
  88             -924 => DB_ERROR_CONNECT_FAILED
  89         );
  90     }
  91
  92     // }}}
  93     // {{{ connect()
  94
  95     function connect($dsninfo, $persistent = false)
  96     {
  97         if (!DB::assertExtension('interbase')) {
  98             return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
  99         }
 100         $this->dsn = $dsninfo;
 101         $dbhost = $dsninfo['hostspec'] ?
 102                   ($dsninfo['hostspec'] . ':' . $dsninfo['database']) :
 103                   $dsninfo['database'];
 104
 105         $connect_function = $persistent ? 'ibase_pconnect' : 'ibase_connect';
 106
 107         $params = array();
 108         $params[] = $dbhost;
 109         $params[] = $dsninfo['username'] ? $dsninfo['username'] : null;
 110         $params[] = $dsninfo['password'] ? $dsninfo['password'] : null;
 111         $params[] = isset($dsninfo['charset']) ? $dsninfo['charset'] : null;
 112         $params[] = isset($dsninfo['buffers']) ? $dsninfo['buffers'] : null;
 113         $params[] = isset($dsninfo['dialect']) ? $dsninfo['dialect'] : null;
 114         $params[] = isset($dsninfo['role'])    ? $dsninfo['role'] : null;
 115
 116         $conn = @call_user_func_array($connect_function, $params);
 117         if (!$conn) {
 118             return $this->ibaseRaiseError(DB_ERROR_CONNECT_FAILED);
 119         }
 120         $this->connection = $conn;
 121         if ($this->dsn['dbsyntax'] == 'firebird') {
 122             $this->features['limit'] = 'alter';
 123         }
 124         return DB_OK;
 125     }
 126
 127     // }}}
 128     // {{{ disconnect()
 129
 130     function disconnect()
 131     {
 132         $ret = @ibase_close($this->connection);
 133         $this->connection = null;
 134         return $ret;
 135     }
 136
 137     // }}}
 138     // {{{ simpleQuery()
 139
 140     function simpleQuery($query)
 141     {
 142         $ismanip = DB::isManip($query);
 143         $this->last_query = $query;
 144         $query = $this->modifyQuery($query);
 145         $result = @ibase_query($this->connection, $query);
 146         if (!$result) {
 147             return $this->ibaseRaiseError();
 148         }
 149         if ($this->autocommit && $ismanip) {
 150             @ibase_commit($this->connection);
 151         }
 152         // Determine which queries that should return data, and which
 153         // should return an error code only.
 154         return $ismanip ? DB_OK : $result;
 155     }
 156
 157     // }}}
 158     // {{{ modifyLimitQuery()
 159
 160     /**
 161      * This method is used by backends to alter limited queries
 162      * Uses the new FIRST n SKIP n Firebird 1.0 syntax, so it is
 163      * only compatible with Firebird 1.x
 164      *
 165      * @param string  $query query to modify
 166      * @param integer $from  the row to start to fetching
 167      * @param integer $count the numbers of rows to fetch
 168      *
 169      * @return the new (modified) query
 170      * @author Ludovico Magnocavallo <ludo@sumatrasolutions.com>
 171      * @access private
 172      */
 173     function modifyLimitQuery($query, $from, $count)
 174     {
 175         if ($this->dsn['dbsyntax'] == 'firebird') {
 176             //$from++; // SKIP starts from 1, ie SKIP 1 starts from the first record
 177                            // (cox) Seems that SKIP starts in 0
 178             $query = preg_replace('/^\s*select\s(.*)$/is',
 179                                   "SELECT FIRST $count SKIP $from $1", $query);
 180         }
 181         return $query;
 182     }
 183
 184     // }}}
 185     // {{{ nextResult()
 186
 187     /**
 188      * Move the internal ibase result pointer to the next available result
 189      *
 190      * @param a valid fbsql result resource
 191      *
 192      * @access public
 193      *
 194      * @return true if a result is available otherwise return false
 195      */
 196     function nextResult($result)
 197     {
 198         return false;
 199     }
 200
 201     // }}}
 202     // {{{ fetchInto()
 203
 204     /**
 205      * Fetch a row and insert the data into an existing array.
 206      *
 207      * Formating of the array and the data therein are configurable.
 208      * See DB_result::fetchInto() for more information.
 209      *
 210      * @param resource $result    query result identifier
 211      * @param array    $arr       (reference) array where data from the row
 212      *                            should be placed
 213      * @param int      $fetchmode how the resulting array should be indexed
 214      * @param int      $rownum    the row number to fetch
 215      *
 216      * @return mixed DB_OK on success, null when end of result set is
 217      *               reached or on failure
 218      *
 219      * @see DB_result::fetchInto()
 220      * @access private
 221      */
 222     function fetchInto($result, &$arr, $fetchmode, $rownum=null)
 223     {
 224         if ($rownum !== null) {
 225             return $this->ibaseRaiseError(DB_ERROR_NOT_CAPABLE);
 226         }
 227         if ($fetchmode & DB_FETCHMODE_ASSOC) {
 228             if (function_exists('ibase_fetch_assoc')) {
 229                 $arr = @ibase_fetch_assoc($result);
 230             } else {
 231                 $arr = get_object_vars(ibase_fetch_object($result));
 232             }
 233             if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE && $arr) {
 234                 $arr = array_change_key_case($arr, CASE_LOWER);
 235             }
 236         } else {
 237             $arr = @ibase_fetch_row($result);
 238         }
 239         if (!$arr) {
 240             if ($errmsg = @ibase_errmsg()) {
 241                 return $this->ibaseRaiseError(null, $errmsg);
 242             } else {
 243                 return null;
 244             }
 245         }
 246         if ($this->options['portability'] & DB_PORTABILITY_RTRIM) {
 247             $this->_rtrimArrayValues($arr);
 248         }
 249         if ($this->options['portability'] & DB_PORTABILITY_NULL_TO_EMPTY) {
 250             $this->_convertNullArrayValuesToEmpty($arr);
 251         }
 252         return DB_OK;
 253     }
 254
 255     // }}}
 256     // {{{ freeResult()
 257
 258     function freeResult($result)
 259     {
 260         return @ibase_free_result($result);
 261     }
 262
 263     // }}}
 264     // {{{ freeQuery()
 265
 266     function freeQuery($query)
 267     {
 268         @ibase_free_query($query);
 269         return true;
 270     }
 271
 272     // }}}
 273     // {{{ numCols()
 274
 275     function numCols($result)
 276     {
 277         $cols = @ibase_num_fields($result);
 278         if (!$cols) {
 279             return $this->ibaseRaiseError();
 280         }
 281         return $cols;
 282     }
 283
 284     // }}}
 285     // {{{ prepare()
 286
 287     /**
 288      * Prepares a query for multiple execution with execute().
 289      *
 290      * prepare() requires a generic query as string like <code>
 291      *    INSERT INTO numbers VALUES (?, ?, ?)
 292      * </code>.  The <kbd>?</kbd> characters are placeholders.
 293      *
 294      * Three types of placeholders can be used:
 295      *   + <kbd>?</kbd>  a quoted scalar value, i.e. strings, integers
 296      *   + <kbd>!</kbd>  value is inserted 'as is'
 297      *   + <kbd>&</kbd>  requires a file name.  The file's contents get
 298      *                     inserted into the query (i.e. saving binary
 299      *                     data in a db)
 300      *
 301      * Use backslashes to escape placeholder characters if you don't want
 302      * them to be interpreted as placeholders.  Example: <code>
 303      *    "UPDATE foo SET col=? WHERE col='over \& under'"
 304      * </code>
 305      *
 306      * @param string $query query to be prepared
 307      * @return mixed DB statement resource on success. DB_Error on failure.
 308      */
 309     function prepare($query)
 310     {
 311         $tokens   = preg_split('/((?<!\\\)[&?!])/', $query, -1,
 312                                PREG_SPLIT_DELIM_CAPTURE);
 313         $token    = 0;
 314         $types    = array();
 315         $newquery = '';
 316
 317         foreach ($tokens as $key => $val) {
 318             switch ($val) {
 319                 case '?':
 320                     $types[$token++] = DB_PARAM_SCALAR;
 321                     break;
 322                 case '&':
 323                     $types[$token++] = DB_PARAM_OPAQUE;
 324                     break;
 325                 case '!':
 326                     $types[$token++] = DB_PARAM_MISC;
 327                     break;
 328                 default:
 329                     $tokens[$key] = preg_replace('/\\\([&?!])/', "\\1", $val);
 330                     $newquery .= $tokens[$key] . '?';
 331             }
 332         }
 333
 334         $newquery = substr($newquery, 0, -1);
 335         $this->last_query = $query;
 336         $newquery = $this->modifyQuery($newquery);
 337         $stmt = @ibase_prepare($this->connection, $newquery);
 338         $this->prepare_types[(int)$stmt] = $types;
 339         $this->manip_query[(int)$stmt]   = DB::isManip($query);
 340         return $stmt;
 341     }
 342
 343     // }}}
 344     // {{{ execute()
 345
 346     /**
 347      * Executes a DB statement prepared with prepare().
 348      *
 349      * @param resource  $stmt  a DB statement resource returned from prepare()
 350      * @param mixed  $data  array, string or numeric data to be used in
 351      *                      execution of the statement.  Quantity of items
 352      *                      passed must match quantity of placeholders in
 353      *                      query:  meaning 1 for non-array items or the
 354      *                      quantity of elements in the array.
 355      * @return object  a new DB_Result or a DB_Error when fail
 356      * @see DB_ibase::prepare()
 357      * @access public
 358      */
 359     function &execute($stmt, $data = array())
 360     {
 361         if (!is_array($data)) {
 362             $data = array($data);
 363         }
 364
 365         $types =& $this->prepare_types[$stmt];
 366         if (count($types) != count($data)) {
 367             $tmp =& $this->raiseError(DB_ERROR_MISMATCH);
 368             return $tmp;
 369         }
 370
 371         $i = 0;
 372         foreach ($data as $key => $value) {
 373             if ($types[$i] == DB_PARAM_MISC) {
 374                 /*
 375                  * ibase doesn't seem to have the ability to pass a
 376                  * parameter along unchanged, so strip off quotes from start
 377                  * and end, plus turn two single quotes to one single quote,
 378                  * in order to avoid the quotes getting escaped by
 379                  * ibase and ending up in the database.
 380                  */
 381                 $data[$key] = preg_replace("/^'(.*)'$/", "\\1", $data[$key]);
 382                 $data[$key] = str_replace("''", "'", $data[$key]);
 383             } elseif ($types[$i] == DB_PARAM_OPAQUE) {
 384                 $fp = @fopen($data[$key], 'rb');
 385                 if (!$fp) {
 386                     $tmp =& $this->raiseError(DB_ERROR_ACCESS_VIOLATION);
 387                     return $tmp;
 388                 }
 389                 $data[$key] = fread($fp, filesize($data[$key]));
 390                 fclose($fp);
 391             }
 392             $i++;
 393         }
 394
 395         array_unshift($data, $stmt);
 396
 397         $res = call_user_func_array('ibase_execute', $data);
 398         if (!$res) {
 399             $tmp =& $this->ibaseRaiseError();
 400             return $tmp;
 401         }
 402         /* XXX need this?
 403         if ($this->autocommit && $this->manip_query[(int)$stmt]) {
 404             @ibase_commit($this->connection);
 405         }*/
 406         if ($this->manip_query[(int)$stmt]) {
 407             $tmp = DB_OK;
 408         } else {
 409             $tmp =& new DB_result($this, $res);
 410         }
 411         return $tmp;
 412     }
 413
 414     /**
 415      * Free the internal resources associated with a prepared query.
 416      *
 417      * @param $stmt The interbase_query resource type
 418      *
 419      * @return bool true on success, false if $result is invalid
 420      */
 421     function freePrepared($stmt)
 422     {
 423         if (!is_resource($stmt)) {
 424             return false;
 425         }
 426         @ibase_free_query($stmt);
 427         unset($this->prepare_tokens[(int)$stmt]);
 428         unset($this->prepare_types[(int)$stmt]);
 429         unset($this->manip_query[(int)$stmt]);
 430         return true;
 431     }
 432
 433     // }}}
 434     // {{{ autoCommit()
 435
 436     function autoCommit($onoff = false)
 437     {
 438         $this->autocommit = $onoff ? 1 : 0;
 439         return DB_OK;
 440     }
 441
 442     // }}}
 443     // {{{ commit()
 444
 445     function commit()
 446     {
 447         return @ibase_commit($this->connection);
 448     }
 449
 450     // }}}
 451     // {{{ rollback()
 452
 453     function rollback()
 454     {
 455         return @ibase_rollback($this->connection);
 456     }
 457
 458     // }}}
 459     // {{{ transactionInit()
 460
 461     function transactionInit($trans_args = 0)
 462     {
 463         return $trans_args ? @ibase_trans($trans_args, $this->connection) : @ibase_trans();
 464     }
 465
 466     // }}}
 467     // {{{ nextId()
 468
 469     /**
 470      * Returns the next free id in a sequence
 471      *
 472      * @param string  $seq_name  name of the sequence
 473      * @param boolean $ondemand  when true, the seqence is automatically
 474      *                           created if it does not exist
 475      *
 476      * @return int  the next id number in the sequence.  DB_Error if problem.
 477      *
 478      * @internal
 479      * @see DB_common::nextID()
 480      * @access public
 481      */
 482     function nextId($seq_name, $ondemand = true)
 483     {
 484         $sqn = strtoupper($this->getSequenceName($seq_name));
 485         $repeat = 0;
 486         do {
 487             $this->pushErrorHandling(PEAR_ERROR_RETURN);
 488             $result =& $this->query("SELECT GEN_ID(${sqn}, 1) "
 489                                    . 'FROM RDB$GENERATORS '
 490                                    . "WHERE RDB\$GENERATOR_NAME='${sqn}'");
 491             $this->popErrorHandling();
 492             if ($ondemand && DB::isError($result)) {
 493                 $repeat = 1;
 494                 $result = $this->createSequence($seq_name);
 495                 if (DB::isError($result)) {
 496                     return $result;
 497                 }
 498             } else {
 499                 $repeat = 0;
 500             }
 501         } while ($repeat);
 502         if (DB::isError($result)) {
 503             return $this->raiseError($result);
 504         }
 505         $arr = $result->fetchRow(DB_FETCHMODE_ORDERED);
 506         $result->free();
 507         return $arr[0];
 508     }
 509
 510     // }}}
 511     // {{{ createSequence()
 512
 513     /**
 514      * Create the sequence
 515      *
 516      * @param string $seq_name the name of the sequence
 517      * @return mixed DB_OK on success or DB error on error
 518      * @access public
 519      */
 520     function createSequence($seq_name)
 521     {
 522         $sqn = strtoupper($this->getSequenceName($seq_name));
 523         $this->pushErrorHandling(PEAR_ERROR_RETURN);
 524         $result = $this->query("CREATE GENERATOR ${sqn}");
 525         $this->popErrorHandling();
 526
 527         return $result;
 528     }
 529
 530     // }}}
 531     // {{{ dropSequence()
 532
 533     /**
 534      * Drop a sequence
 535      *
 536      * @param string $seq_name the name of the sequence
 537      * @return mixed DB_OK on success or DB error on error
 538      * @access public
 539      */
 540     function dropSequence($seq_name)
 541     {
 542         $sqn = strtoupper($this->getSequenceName($seq_name));
 543         return $this->query('DELETE FROM RDB$GENERATORS '
 544                             . "WHERE RDB\$GENERATOR_NAME='${sqn}'");
 545     }
 546
 547     // }}}
 548     // {{{ _ibaseFieldFlags()
 549
 550     /**
 551      * get the Flags of a Field
 552      *
 553      * @param string $field_name the name of the field
 554      * @param string $table_name the name of the table
 555      *
 556      * @return string The flags of the field ("primary_key", "unique_key", "not_null"
 557      *                "default", "computed" and "blob" are supported)
 558      * @access private
 559      */
 560     function _ibaseFieldFlags($field_name, $table_name)
 561     {
 562         $sql = 'SELECT R.RDB$CONSTRAINT_TYPE CTYPE'
 563                .' FROM RDB$INDEX_SEGMENTS I'
 564                .'  JOIN RDB$RELATION_CONSTRAINTS R ON I.RDB$INDEX_NAME=R.RDB$INDEX_NAME'
 565                .' WHERE I.RDB$FIELD_NAME=\'' . $field_name . '\''
 566                .'  AND UPPER(R.RDB$RELATION_NAME)=\'' . strtoupper($table_name) . '\'';
 567
 568         $result = @ibase_query($this->connection, $sql);
 569         if (!$result) {
 570             return $this->ibaseRaiseError();
 571         }
 572
 573         $flags = '';
 574         if ($obj = @ibase_fetch_object($result)) {
 575             @ibase_free_result($result);
 576             if (isset($obj->CTYPE)  && trim($obj->CTYPE) == 'PRIMARY KEY') {
 577                 $flags .= 'primary_key ';
 578             }
 579             if (isset($obj->CTYPE)  && trim($obj->CTYPE) == 'UNIQUE') {
 580                 $flags .= 'unique_key ';
 581             }
 582         }
 583
 584         $sql = 'SELECT R.RDB$NULL_FLAG AS NFLAG,'
 585                .'  R.RDB$DEFAULT_SOURCE AS DSOURCE,'
 586                .'  F.RDB$FIELD_TYPE AS FTYPE,'
 587                .'  F.RDB$COMPUTED_SOURCE AS CSOURCE'
 588                .' FROM RDB$RELATION_FIELDS R '
 589                .'  JOIN RDB$FIELDS F ON R.RDB$FIELD_SOURCE=F.RDB$FIELD_NAME'
 590                .' WHERE UPPER(R.RDB$RELATION_NAME)=\'' . strtoupper($table_name) . '\''
 591                .'  AND R.RDB$FIELD_NAME=\'' . $field_name . '\'';
 592
 593         $result = @ibase_query($this->connection, $sql);
 594         if (!$result) {
 595             return $this->ibaseRaiseError();
 596         }
 597         if ($obj = @ibase_fetch_object($result)) {
 598             @ibase_free_result($result);
 599             if (isset($obj->NFLAG)) {
 600                 $flags .= 'not_null ';
 601             }
 602             if (isset($obj->DSOURCE)) {
 603                 $flags .= 'default ';
 604             }
 605             if (isset($obj->CSOURCE)) {
 606                 $flags .= 'computed ';
 607             }
 608             if (isset($obj->FTYPE)  && $obj->FTYPE == 261) {
 609                 $flags .= 'blob ';
 610             }
 611         }
 612
 613         return trim($flags);
 614     }
 615
 616     // }}}
 617     // {{{ tableInfo()
 618
 619     /**
 620      * Returns information about a table or a result set.
 621      *
 622      * NOTE: only supports 'table' and 'flags' if <var>$result</var>
 623      * is a table name.
 624      *
 625      * @param object|string  $result  DB_result object from a query or a
 626      *                                string containing the name of a table
 627      * @param int            $mode    a valid tableInfo mode
 628      * @return array  an associative array with the information requested
 629      *                or an error object if something is wrong
 630      * @access public
 631      * @internal
 632      * @see DB_common::tableInfo()
 633      */
 634     function tableInfo($result, $mode = null)
 635     {
 636         if (isset($result->result)) {
 637             /*
 638              * Probably received a result object.
 639              * Extract the result resource identifier.
 640              */
 641             $id = $result->result;
 642             $got_string = false;
 643         } elseif (is_string($result)) {
 644             /*
 645              * Probably received a table name.
 646              * Create a result resource identifier.
 647              */
 648              $id = @ibase_query($this->connection,
 649                                 "SELECT * FROM $result WHERE 1=0");
 650             $got_string = true;
 651         } else {
 652             /*
 653              * Probably received a result resource identifier.
 654              * Copy it.
 655              * Depricated.  Here for compatibility only.
 656              */
 657              $id = $result;
 658             $got_string = false;
 659         }
 660
 661         if (!is_resource($id)) {
 662             return $this->ibaseRaiseError(DB_ERROR_NEED_MORE_DATA);
 663         }
 664
 665         if ($this->options['portability'] & DB_PORTABILITY_LOWERCASE) {
 666             $case_func = 'strtolower';
 667         } else {
 668             $case_func = 'strval';
 669         }
 670
 671         $count = @ibase_num_fields($id);
 672
 673         // made this IF due to performance (one if is faster than $count if's)
 674         if (!$mode) {
 675             for ($i=0; $i<$count; $i++) {
 676                 $info = @ibase_field_info($id, $i);
 677                 $res[$i]['table'] = $got_string ? $case_func($result) : '';
 678                 $res[$i]['name']  = $case_func($info['name']);
 679                 $res[$i]['type']  = $info['type'];
 680                 $res[$i]['len']   = $info['length'];
 681                 $res[$i]['flags'] = ($got_string) ? $this->_ibaseFieldFlags($info['name'], $result) : '';
 682             }
 683         } else { // full
 684             $res['num_fields']= $count;
 685
 686             for ($i=0; $i<$count; $i++) {
 687                 $info = @ibase_field_info($id, $i);
 688                 $res[$i]['table'] = $got_string ? $case_func($result) : '';
 689                 $res[$i]['name']  = $case_func($info['name']);
 690                 $res[$i]['type']  = $info['type'];
 691                 $res[$i]['len']   = $info['length'];
 692                 $res[$i]['flags'] = ($got_string) ? $this->_ibaseFieldFlags($info['name'], $result) : '';
 693
 694                 if ($mode & DB_TABLEINFO_ORDER) {
 695                     $res['order'][$res[$i]['name']] = $i;
 696                 }
 697                 if ($mode & DB_TABLEINFO_ORDERTABLE) {
 698                     $res['ordertable'][$res[$i]['table']][$res[$i]['name']] = $i;
 699                 }
 700             }
 701         }
 702
 703         // free the result only if we were called on a table
 704         if ($got_string) {
 705             @ibase_free_result($id);
 706         }
 707         return $res;
 708     }
 709
 710     // }}}
 711     // {{{ ibaseRaiseError()
 712
 713     /**
 714      * Gather information about an error, then use that info to create a
 715      * DB error object and finally return that object.
 716      *
 717      * @param  integer  $db_errno  PEAR error number (usually a DB constant) if
 718      *                             manually raising an error
 719      * @param  string  $native_errmsg  text of error message if known
 720      * @return object  DB error object
 721      * @see DB_common::errorCode()
 722      * @see DB_common::raiseError()
 723      */
 724     function &ibaseRaiseError($db_errno = null, $native_errmsg = null)
 725     {
 726         if ($native_errmsg === null) {
 727             $native_errmsg = @ibase_errmsg();
 728         }
 729         // memo for the interbase php module hackers: we need something similar
 730         // to mysql_errno() to retrieve error codes instead of this ugly hack
 731         if (preg_match('/^([^0-9\-]+)([0-9\-]+)\s+(.*)$/', $native_errmsg, $m)) {
 732             $native_errno = (int)$m[2];
 733         } else {
 734             $native_errno = null;
 735         }
 736         // try to map the native error to the DB one
 737         if ($db_errno === null) {
 738             if ($native_errno) {
 739                 // try to interpret Interbase error code (that's why we need ibase_errno()
 740                 // in the interbase module to return the real error code)
 741                 switch ($native_errno) {
 742                     case -204:
 743                         if (is_int(strpos($m[3], 'Table unknown'))) {
 744                             $db_errno = DB_ERROR_NOSUCHTABLE;
 745                         }
 746                         break;
 747                     default:
 748                         $db_errno = $this->errorCode($native_errno);
 749                 }
 750             } else {
 751                 $error_regexps = array(
 752                     '/[tT]able not found/' => DB_ERROR_NOSUCHTABLE,
 753                     '/[tT]able .* already exists/' => DB_ERROR_ALREADY_EXISTS,
 754                     '/validation error for column .* value "\*\*\* null/' => DB_ERROR_CONSTRAINT_NOT_NULL,
 755                     '/violation of [\w ]+ constraint/' => DB_ERROR_CONSTRAINT,
 756                     '/conversion error from string/' => DB_ERROR_INVALID_NUMBER,
 757                     '/no permission for/' => DB_ERROR_ACCESS_VIOLATION,
 758                     '/arithmetic exception, numeric overflow, or string truncation/' => DB_ERROR_DIVZERO
 759                 );
 760                 foreach ($error_regexps as $regexp => $code) {
 761                     if (preg_match($regexp, $native_errmsg)) {
 762                         $db_errno = $code;
 763                         $native_errno = null;
 764                         break;
 765                     }
 766                 }
 767             }
 768         }
 769         $tmp =& $this->raiseError($db_errno, null, null, null, $native_errmsg);
 770         return $tmp;
 771     }
 772
 773     // }}}
 774
 775 }
 776
 777 /*
 778  * Local variables:
 779  * tab-width: 4
 780  * c-basic-offset: 4
 781  * End:
 782  */
 783
 784 ?>