home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / php / pear / DB / odbc.php < prev    next >
PHP Script  |  2001-02-19  |  9KB  |  331 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2001 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. // | Authors: Stig Bakken <ssb@fast.no>                                   |
  17. // |                                                                      |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // Database independent query interface definition for PHP's ODBC
  21. // extension.
  22. //
  23.  
  24. //
  25. // XXX legend:
  26. //
  27. // XXX ERRORMSG: The error message from the odbc function should
  28. //                 be registered here.
  29. //
  30.  
  31. require_once 'DB/common.php';
  32.  
  33. class DB_odbc extends DB_common
  34. {
  35.     // {{{ properties
  36.  
  37.     var $connection;
  38.     var $phptype, $dbsyntax;
  39.  
  40.     // }}}
  41.     // {{{ constructor
  42.  
  43.     function DB_odbc()
  44.     {
  45.         $this->DB_common();
  46.         $this->phptype = 'odbc';
  47.         $this->dbsyntax = 'sql92';
  48.         $this->features = array(
  49.             'prepare' => true,
  50.             'pconnect' => true,
  51.             'transactions' => false
  52.         );
  53.         $this->errorcode_map = array(
  54.             "01004" => DB_ERROR_TRUNCATED,
  55.             "07001" => DB_ERROR_MISMATCH,
  56.             "21S01" => DB_ERROR_MISMATCH,
  57.             "21S02" => DB_ERROR_MISMATCH,
  58.             "22003" => DB_ERROR_INVALID_NUMBER,
  59.             "22008" => DB_ERROR_INVALID_DATE,
  60.             "22012" => DB_ERROR_DIVZERO,
  61.             "23000" => DB_ERROR_CONSTRAINT,
  62.             "24000" => DB_ERROR_INVALID,
  63.             "34000" => DB_ERROR_INVALID,
  64.             "37000" => DB_ERROR_SYNTAX,
  65.             "42000" => DB_ERROR_SYNTAX,
  66.             "IM001" => DB_ERROR_UNSUPPORTED,
  67.             "S0001" => DB_ERROR_NOT_FOUND,
  68.             "S0002" => DB_ERROR_NOT_FOUND,
  69.             "S0011" => DB_ERROR_ALREADY_EXISTS,
  70.             "S0012" => DB_ERROR_NOT_FOUND,
  71.             "S0021" => DB_ERROR_ALREADY_EXISTS,
  72.             "S0022" => DB_ERROR_NOT_FOUND,
  73.             "S1009" => DB_ERROR_INVALID,
  74.             "S1090" => DB_ERROR_INVALID,
  75.             "S1C00" => DB_ERROR_NOT_CAPABLE
  76.         );
  77.     }
  78.  
  79.     // }}}
  80.     // {{{ connect()
  81.  
  82.     /**
  83.      * Connect to a database and log in as the specified user.
  84.      *
  85.      * @param $dsn the data source name (see DB::parseDSN for syntax)
  86.      * @param $persistent (optional) whether the connection should
  87.      *        be persistent
  88.      *
  89.      * @return int DB_OK on success, a DB error code on failure
  90.      */
  91.     function connect($dsn, $persistent = false) {
  92.         if (is_array($dsn)) {
  93.             $dsninfo = &$dsn;
  94.         } else {
  95.             $dsninfo = DB::parseDSN($dsn);
  96.         }
  97.         if (!$dsninfo || !$dsninfo['phptype']) {
  98.             return $this->raiseError(); // XXX ERRORMSG
  99.         }
  100.         $this->dsn = $dsninfo;
  101.         $this->dbsyntax = $dsninfo['dbsyntax'];
  102.         switch ($this->dbsyntax) {
  103.             case 'solid':
  104.                 $this->features = array(
  105.                     'prepare' => true,
  106.                     'pconnect' => true,
  107.                     'transactions' => true
  108.                 );
  109.                 $default_dsn = 'localhost';
  110.                 break;
  111.             default:
  112.                 break;
  113.         }
  114.         $dbhost = $dsninfo['hostspec'] ? $dsninfo['hostspec'] : 'localhost';
  115.         $user = $dsninfo['username'];
  116.         $pw = $dsninfo['password'];
  117.         DB::assertExtension("odbc");
  118.         if ($this->provides('pconnect')) {
  119.             $connect_function = $persistent ? 'odbc_pconnect' : 'odbc_connect';
  120.         } else {
  121.             $connect_function = 'odbc_connect';
  122.         }
  123.         $conn = @$connect_function($dbhost, $user, $pw);
  124.         if (!is_resource($conn)) {
  125.             return $this->raiseError();
  126.         }
  127.         $this->connection = $conn;
  128.         return DB_OK;
  129.     }
  130.  
  131.     // }}}
  132.     // {{{ disconnect()
  133.  
  134.     function disconnect()
  135.     {
  136.         $err = odbc_close($this->connection); // XXX ERRORMSG
  137.         return $err;
  138.     }
  139.  
  140.     // }}}
  141.     // {{{ simpleQuery()
  142.  
  143.     /**
  144.      * Send a query to ODBC and return the results as a ODBC resource
  145.      * identifier.
  146.      *
  147.      * @param $query the SQL query
  148.      *
  149.      * @return int returns a valid ODBC result for successful SELECT
  150.      * queries, DB_OK for other successful queries.  A DB error code
  151.      * is returned on failure.
  152.      */
  153.     function simpleQuery($query)
  154.     {
  155.         $this->last_query = $query;
  156.         $query = $this->modifyQuery($query);
  157.         $result = odbc_exec($this->connection, $query);
  158.         if (!$result) {
  159.             return $this->raiseError(); // XXX ERRORMSG
  160.         }
  161.         // Determine which queries that should return data, and which
  162.         // should return an error code only.
  163.         return DB::isManip($query) ? DB_OK : $result;
  164.     }
  165.  
  166.     // }}}
  167.     // {{{ fetchRow()
  168.  
  169.     /**
  170.      * Fetch a row and return as array.
  171.      *
  172.      * @param $result result identifier
  173.      * @param $fetchmode how the resulting array should be indexed
  174.      *
  175.      * @return mixed an array on success (associative or ordred, depending on
  176.      *               fetchmode), a false on failure, false if there is no more
  177.      *               data
  178.      */
  179.     function fetchRow($result, $fetchmode = DB_FETCHMODE_DEFAULT)
  180.     {
  181.         if ($fetchmode == DB_FETCHMODE_DEFAULT) {
  182.             $fetchmode = $this->fetchmode;
  183.         }
  184.     
  185.     $cols = odbc_fetch_into($result, &$row);
  186.     if (!$cols) {
  187.         if ($errno = odbc_error($this->connection)) {
  188.         return $this->raiseError($errno);
  189.         } else {
  190.         return null;
  191.         }
  192.     }
  193.     
  194.         if ($fetchmode == DB_FETCHMODE_ORDERED) {
  195.             return $row;
  196.         } else if ($fetchmode == DB_FETCHMODE_ASSOC) {
  197.             for ($i = 0; $i < count($row); $i++) {
  198.                 $colName = odbc_field_name($result, $i+1);
  199.                 $a[$colName] = $row[$i];
  200.             }
  201.             return $a;
  202.         } else {
  203.         return $this->raiseError(); // XXX ERRORMSG
  204.         }
  205.     }
  206.     
  207.     // }}}
  208.     // {{{ freeResult()
  209.  
  210.     function freeResult($result)
  211.     {
  212.         $err = odbc_free_result($result); // XXX ERRORMSG
  213.         return $err;
  214.     }
  215.  
  216.     // }}}
  217.     // {{{ quoteString()
  218.  
  219.     function quoteString($string)
  220.     {
  221.         return str_replace("'", "''", $string);
  222.     }
  223.  
  224.     // }}}
  225.     // {{{ numCols()
  226.  
  227.     function numCols($result)
  228.     {
  229.         $cols = @odbc_num_fields($result);
  230.         if (!$cols) {
  231.             return $this->raiseError($php_errormsg);
  232.         }
  233.         return $cols;
  234.     }
  235.  
  236.     // }}}
  237.     // {{{ numRows()
  238.  
  239.     /**
  240.      * ODBC does not support counting rows in the result set of
  241.      * SELECTs.
  242.      *
  243.      * @param $result the odbc result resource
  244.      * @return a DB error
  245.      */
  246.     function numRows($result)
  247.     {
  248.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  249.     }
  250.  
  251.     // }}}
  252.     // {{{ errorNative()
  253.  
  254.     /**
  255.      * Get the native error code of the last error (if any) that
  256.      * occured on the current connection.
  257.      *
  258.      * @access public
  259.      *
  260.      * @return int ODBC error code
  261.      */
  262.  
  263.     function errorNative()
  264.     {
  265.         if (is_resource($this->connection)) {
  266.             return odbc_error($this->connection);
  267.         } else {
  268.             return odbc_error();
  269.         }
  270.     }
  271.  
  272.     // }}}
  273.     // {{{ autoCommit()
  274.  
  275.     function autoCommit($onoff = false)
  276.     {
  277.         if (!@odbc_autocommit($this->connection, $onoff)) {
  278.             return $this->raiseError($php_errormsg);
  279.         }
  280.         return DB_OK;
  281.     }
  282.  
  283.     // }}}
  284.     // {{{ commit()
  285.  
  286.     function commit()
  287.     {
  288.         if (!@odbc_commit($this->connection)) {
  289.             return $this->raiseError($php_errormsg);
  290.         }
  291.         return DB_OK;
  292.     }
  293.  
  294.     // }}}
  295.     // {{{ rollback()
  296.  
  297.     function rollback()
  298.     {
  299.         if (!@odbc_commit($this->connection)) {
  300.             return $this->raiseError($php_errormsg);
  301.         }
  302.         return DB_OK;
  303.     }
  304.  
  305.     // }}}
  306.     // {{{ odbcRaiseError()
  307.  
  308.     function odbcRaiseError($errno = null)
  309.     {
  310.         if (is_resource($this->connection)) {
  311.             $message = odbc_errormsg($this->connection);
  312.             $code = odbc_error($this->connection);
  313.         } else {
  314.             $message = odbc_errormsg();
  315.             $code = odbc_error();
  316.         }
  317.         if ($errno === null) {
  318.             return $this->raiseError($this->errorCode($code));
  319.         }
  320.         return $this->raiseError($this->errorCode($errno));
  321.     }
  322.  
  323.     // }}}
  324. }
  325.  
  326. // Local variables:
  327. // tab-width: 4
  328. // c-basic-offset: 4
  329. // End:
  330. ?>
  331.