DB
[ class tree: DB ] [ index: DB ] [ all elements ]

Source for file sybase.php

Documentation is available at sybase.php

  1. <?php
  2.  
  3. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  4.  
  5. /**
  6.  * The PEAR DB driver for PHP's sybase extension
  7.  * for interacting with Sybase databases
  8.  *
  9.  * PHP versions 4 and 5
  10.  *
  11.  * LICENSE: This source file is subject to version 3.0 of the PHP license
  12.  * that is available through the world-wide-web at the following URI:
  13.  * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
  14.  * the PHP License and are unable to obtain it through the web, please
  15.  * send a note to license@php.net so we can mail you a copy immediately.
  16.  *
  17.  * @category   Database
  18.  * @package    DB
  19.  * @author     Sterling Hughes <sterling@php.net>
  20.  * @author     Antônio Carlos Venâncio Júnior <floripa@php.net>
  21.  * @author     Daniel Convissor <danielc@php.net>
  22.  * @copyright  1997-2007 The PHP Group
  23.  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  24.  * @version    CVS: $Id: sybase.php 242771 2007-09-21 13:40:42Z aharvey $
  25.  * @link       http://pear.php.net/package/DB
  26.  */
  27.  
  28. /**
  29.  * Obtain the DB_common class so it can be extended from
  30.  */
  31. require_once 'DB/common.php';
  32.  
  33. /**
  34.  * The methods PEAR DB uses to interact with PHP's sybase extension
  35.  * for interacting with Sybase databases
  36.  *
  37.  * These methods overload the ones declared in DB_common.
  38.  *
  39.  * WARNING:  This driver may fail with multiple connections under the
  40.  * same user/pass/host and different databases.
  41.  *
  42.  * @category   Database
  43.  * @package    DB
  44.  * @author     Sterling Hughes <sterling@php.net>
  45.  * @author     Antônio Carlos Venâncio Júnior <floripa@php.net>
  46.  * @author     Daniel Convissor <danielc@php.net>
  47.  * @copyright  1997-2007 The PHP Group
  48.  * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
  49.  * @version    Release: 1.7.14
  50.  * @link       http://pear.php.net/package/DB
  51.  */
  52. class DB_sybase extends DB_common
  53. {
  54.     // {{{ properties
  55.  
  56.     /**
  57.      * The DB driver type (mysql, oci8, odbc, etc.)
  58.      * @var string 
  59.      */
  60.     var $phptype = 'sybase';
  61.  
  62.     /**
  63.      * The database syntax variant to be used (db2, access, etc.), if any
  64.      * @var string 
  65.      */
  66.     var $dbsyntax = 'sybase';
  67.  
  68.     /**
  69.      * The capabilities of this DB implementation
  70.      *
  71.      * The 'new_link' element contains the PHP version that first provided
  72.      * new_link support for this DBMS.  Contains false if it's unsupported.
  73.      *
  74.      * Meaning of the 'limit' element:
  75.      *   + 'emulate' = emulate with fetch row by number
  76.      *   + 'alter'   = alter the query
  77.      *   + false     = skip rows
  78.      *
  79.      * @var array 
  80.      */
  81.     var $features = array(
  82.         'limit'         => 'emulate',
  83.         'new_link'      => false,
  84.         'numrows'       => true,
  85.         'pconnect'      => true,
  86.         'prepare'       => false,
  87.         'ssl'           => false,
  88.         'transactions'  => true,
  89.     );
  90.  
  91.     /**
  92.      * A mapping of native error codes to DB error codes
  93.      * @var array 
  94.      */
  95.     var $errorcode_map = array(
  96.     );
  97.  
  98.     /**
  99.      * The raw database connection created by PHP
  100.      * @var resource 
  101.      */
  102.     var $connection;
  103.  
  104.     /**
  105.      * The DSN information for connecting to a database
  106.      * @var array 
  107.      */
  108.     var $dsn = array();
  109.  
  110.  
  111.     /**
  112.      * Should data manipulation queries be committed automatically?
  113.      * @var bool 
  114.      * @access private
  115.      */
  116.     var $autocommit = true;
  117.  
  118.     /**
  119.      * The quantity of transactions begun
  120.      *
  121.      * {@internal  While this is private, it can't actually be designated
  122.      * private in PHP 5 because it is directly accessed in the test suite.}}}
  123.      *
  124.      * @var integer 
  125.      * @access private
  126.      */
  127.     var $transaction_opcount = 0;
  128.  
  129.     /**
  130.      * The database specified in the DSN
  131.      *
  132.      * It's a fix to allow calls to different databases in the same script.
  133.      *
  134.      * @var string 
  135.      * @access private
  136.      */
  137.     var $_db '';
  138.  
  139.  
  140.     // }}}
  141.     // {{{ constructor
  142.  
  143.     /**
  144.      * This constructor calls <kbd>$this->DB_common()</kbd>
  145.      *
  146.      * @return void 
  147.      */
  148.     function DB_sybase()
  149.     {
  150.         $this->DB_common();
  151.     }
  152.  
  153.     // }}}
  154.     // {{{ connect()
  155.  
  156.     /**
  157.      * Connect to the database server, log in and open the database
  158.      *
  159.      * Don't call this method directly.  Use DB::connect() instead.
  160.      *
  161.      * PEAR DB's sybase driver supports the following extra DSN options:
  162.      *   + appname       The application name to use on this connection.
  163.      *                   Available since PEAR DB 1.7.0.
  164.      *   + charset       The character set to use on this connection.
  165.      *                   Available since PEAR DB 1.7.0.
  166.      *
  167.      * @param array $dsn         the data source name
  168.      * @param bool  $persistent  should the connection be persistent?
  169.      *
  170.      * @return int  DB_OK on success. A DB_Error object on failure.
  171.      */
  172.     function connect($dsn$persistent = false)
  173.     {
  174.         if (!PEAR::loadExtension('sybase'&&
  175.             !PEAR::loadExtension('sybase_ct'))
  176.         {
  177.             return $this->raiseError(DB_ERROR_EXTENSION_NOT_FOUND);
  178.         }
  179.  
  180.         $this->dsn = $dsn;
  181.         if ($dsn['dbsyntax']{
  182.             $this->dbsyntax = $dsn['dbsyntax'];
  183.         }
  184.  
  185.         $dsn['hostspec'$dsn['hostspec'$dsn['hostspec''localhost';
  186.         $dsn['password'!empty($dsn['password']$dsn['password': false;
  187.         $dsn['charset'= isset($dsn['charset']$dsn['charset': false;
  188.         $dsn['appname'= isset($dsn['appname']$dsn['appname': false;
  189.  
  190.         $connect_function $persistent 'sybase_pconnect' 'sybase_connect';
  191.  
  192.         if ($dsn['username']{
  193.             $this->connection = @$connect_function($dsn['hostspec'],
  194.                                                    $dsn['username'],
  195.                                                    $dsn['password'],
  196.                                                    $dsn['charset'],
  197.                                                    $dsn['appname']);
  198.         else {
  199.             return $this->raiseError(DB_ERROR_CONNECT_FAILED,
  200.                                      nullnullnull,
  201.                                      'The DSN did not contain a username.');
  202.         }
  203.  
  204.         if (!$this->connection{
  205.             return $this->raiseError(DB_ERROR_CONNECT_FAILED,
  206.                                      nullnullnull,
  207.                                      @sybase_get_last_message());
  208.         }
  209.  
  210.         if ($dsn['database']{
  211.             if (!@sybase_select_db($dsn['database']$this->connection)) {
  212.                 return $this->raiseError(DB_ERROR_NODBSELECTED,
  213.                                          nullnullnull,
  214.                                          @sybase_get_last_message());
  215.             }
  216.             $this->_db $dsn['database'];
  217.         }
  218.  
  219.         return DB_OK;
  220.     }
  221.  
  222.     // }}}
  223.     // {{{ disconnect()
  224.  
  225.     /**
  226.      * Disconnects from the database server
  227.      *
  228.      * @return bool  TRUE on success, FALSE on failure
  229.      */
  230.     function disconnect()
  231.     {
  232.         $ret @sybase_close($this->connection);
  233.         $this->connection = null;
  234.         return $ret;
  235.     }
  236.  
  237.     // }}}
  238.     // {{{ simpleQuery()
  239.  
  240.     /**
  241.      * Sends a query to the database server
  242.      *
  243.      * @param string  the SQL query string
  244.      *
  245.      * @return mixed  + a PHP result resrouce for successful SELECT queries
  246.      *                 + the DB_OK constant for other successful queries
  247.      *                 + a DB_Error object on failure
  248.      */
  249.     function simpleQuery($query)
  250.     {
  251.         $ismanip $this->_checkManip($query);
  252.         $this->last_query = $query;
  253.         if ($this->_db && !@sybase_select_db($this->_db$this->connection)) {
  254.             return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
  255.         }
  256.         $query $this->modifyQuery($query);
  257.         if (!$this->autocommit && $ismanip{
  258.             if ($this->transaction_opcount == 0{
  259.                 $result @sybase_query('BEGIN TRANSACTION'$this->connection);
  260.                 if (!$result{
  261.                     return $this->sybaseRaiseError();
  262.                 }
  263.             }
  264.             $this->transaction_opcount++;
  265.         }
  266.         $result @sybase_query($query$this->connection);
  267.         if (!$result{
  268.             return $this->sybaseRaiseError();
  269.         }
  270.         if (is_resource($result)) {
  271.             return $result;
  272.         }
  273.         // Determine which queries that should return data, and which
  274.         // should return an error code only.
  275.         return $ismanip DB_OK : $result;
  276.     }
  277.  
  278.     // }}}
  279.     // {{{ nextResult()
  280.  
  281.     /**
  282.      * Move the internal sybase result pointer to the next available result
  283.      *
  284.      * @param valid sybase result resource
  285.      *
  286.      * @access public
  287.      *
  288.      * @return true if a result is available otherwise return false
  289.      */
  290.     function nextResult($result)
  291.     {
  292.         return false;
  293.     }
  294.  
  295.     // }}}
  296.     // {{{ fetchInto()
  297.  
  298.     /**
  299.      * Places a row from the result set into the given array
  300.      *
  301.      * Formating of the array and the data therein are configurable.
  302.      * See DB_result::fetchInto() for more information.
  303.      *
  304.      * This method is not meant to be called directly.  Use
  305.      * DB_result::fetchInto() instead.  It can't be declared "protected"
  306.      * because DB_result is a separate object.
  307.      *
  308.      * @param resource $result    the query result resource
  309.      * @param array    $arr       the referenced array to put the data in
  310.      * @param int      $fetchmode how the resulting array should be indexed
  311.      * @param int      $rownum    the row number to fetch (0 = first row)
  312.      *
  313.      * @return mixed  DB_OK on success, NULL when the end of a result set is
  314.      *                  reached or on failure
  315.      *
  316.      * @see DB_result::fetchInto()
  317.      */
  318.     function fetchInto($result&$arr$fetchmode$rownum = null)
  319.     {
  320.         if ($rownum !== null{
  321.             if (!@sybase_data_seek($result$rownum)) {
  322.                 return null;
  323.             }
  324.         }
  325.         if ($fetchmode DB_FETCHMODE_ASSOC{
  326.             if (function_exists('sybase_fetch_assoc')) {
  327.                 $arr @sybase_fetch_assoc($result);
  328.             else {
  329.                 if ($arr @sybase_fetch_array($result)) {
  330.                     foreach ($arr as $key => $value{
  331.                         if (is_int($key)) {
  332.                             unset($arr[$key]);
  333.                         }
  334.                     }
  335.                 }
  336.             }
  337.             if ($this->options['portability'DB_PORTABILITY_LOWERCASE && $arr{
  338.                 $arr array_change_key_case($arrCASE_LOWER);
  339.             }
  340.         else {
  341.             $arr @sybase_fetch_row($result);
  342.         }
  343.         if (!$arr{
  344.             return null;
  345.         }
  346.         if ($this->options['portability'DB_PORTABILITY_RTRIM{
  347.             $this->_rtrimArrayValues($arr);
  348.         }
  349.         if ($this->options['portability'DB_PORTABILITY_NULL_TO_EMPTY{
  350.             $this->_convertNullArrayValuesToEmpty($arr);
  351.         }
  352.         return DB_OK;
  353.     }
  354.  
  355.     // }}}
  356.     // {{{ freeResult()
  357.  
  358.     /**
  359.      * Deletes the result set and frees the memory occupied by the result set
  360.      *
  361.      * This method is not meant to be called directly.  Use
  362.      * DB_result::free() instead.  It can't be declared "protected"
  363.      * because DB_result is a separate object.
  364.      *
  365.      * @param resource $result  PHP's query result resource
  366.      *
  367.      * @return bool  TRUE on success, FALSE if $result is invalid
  368.      *
  369.      * @see DB_result::free()
  370.      */
  371.     function freeResult($result)
  372.     {
  373.         return is_resource($result? sybase_free_result($result: false;
  374.     }
  375.  
  376.     // }}}
  377.     // {{{ numCols()
  378.  
  379.     /**
  380.      * Gets the number of columns in a result set
  381.      *
  382.      * This method is not meant to be called directly.  Use
  383.      * DB_result::numCols() instead.  It can't be declared "protected"
  384.      * because DB_result is a separate object.
  385.      *
  386.      * @param resource $result  PHP's query result resource
  387.      *
  388.      * @return int  the number of columns.  A DB_Error object on failure.
  389.      *
  390.      * @see DB_result::numCols()
  391.      */
  392.     function numCols($result)
  393.     {
  394.         $cols @sybase_num_fields($result);
  395.         if (!$cols{
  396.             return $this->sybaseRaiseError();
  397.         }
  398.         return $cols;
  399.     }
  400.  
  401.     // }}}
  402.     // {{{ numRows()
  403.  
  404.     /**
  405.      * Gets the number of rows in a result set
  406.      *
  407.      * This method is not meant to be called directly.  Use
  408.      * DB_result::numRows() instead.  It can't be declared "protected"
  409.      * because DB_result is a separate object.
  410.      *
  411.      * @param resource $result  PHP's query result resource
  412.      *
  413.      * @return int  the number of rows.  A DB_Error object on failure.
  414.      *
  415.      * @see DB_result::numRows()
  416.      */
  417.     function numRows($result)
  418.     {
  419.         $rows @sybase_num_rows($result);
  420.         if ($rows === false{
  421.             return $this->sybaseRaiseError();
  422.         }
  423.         return $rows;
  424.     }
  425.  
  426.     // }}}
  427.     // {{{ affectedRows()
  428.  
  429.     /**
  430.      * Determines the number of rows affected by a data maniuplation query
  431.      *
  432.      * 0 is returned for queries that don't manipulate data.
  433.      *
  434.      * @return int  the number of rows.  A DB_Error object on failure.
  435.      */
  436.     function affectedRows()
  437.     {
  438.         if ($this->_last_query_manip{
  439.             $result @sybase_affected_rows($this->connection);
  440.         else {
  441.             $result = 0;
  442.         }
  443.         return $result;
  444.      }
  445.  
  446.     // }}}
  447.     // {{{ nextId()
  448.  
  449.     /**
  450.      * Returns the next free id in a sequence
  451.      *
  452.      * @param string  $seq_name  name of the sequence
  453.      * @param boolean $ondemand  when true, the seqence is automatically
  454.      *                             created if it does not exist
  455.      *
  456.      * @return int  the next id number in the sequence.
  457.      *                A DB_Error object on failure.
  458.      *
  459.      * @see DB_common::nextID(), DB_common::getSequenceName(),
  460.      *       DB_sybase::createSequence(), DB_sybase::dropSequence()
  461.      */
  462.     function nextId($seq_name$ondemand = true)
  463.     {
  464.         $seqname $this->getSequenceName($seq_name);
  465.         if ($this->_db && !@sybase_select_db($this->_db$this->connection)) {
  466.             return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
  467.         }
  468.         $repeat = 0;
  469.         do {
  470.             $this->pushErrorHandling(PEAR_ERROR_RETURN);
  471.             $result $this->query("INSERT INTO $seqname (vapor) VALUES (0)");
  472.             $this->popErrorHandling();
  473.             if ($ondemand && DB::isError($result&&
  474.                 ($result->getCode(== DB_ERROR || $result->getCode(== DB_ERROR_NOSUCHTABLE))
  475.             {
  476.                 $repeat = 1;
  477.                 $result $this->createSequence($seq_name);
  478.                 if (DB::isError($result)) {
  479.                     return $this->raiseError($result);
  480.                 }
  481.             elseif (!DB::isError($result)) {
  482.                 $result $this->query("SELECT @@IDENTITY FROM $seqname");
  483.                 $repeat = 0;
  484.             else {
  485.                 $repeat = false;
  486.             }
  487.         while ($repeat);
  488.         if (DB::isError($result)) {
  489.             return $this->raiseError($result);
  490.         }
  491.         $result $result->fetchRow(DB_FETCHMODE_ORDERED);
  492.         return $result[0];
  493.     }
  494.  
  495.     /**
  496.      * Creates a new sequence
  497.      *
  498.      * @param string $seq_name  name of the new sequence
  499.      *
  500.      * @return int  DB_OK on success.  A DB_Error object on failure.
  501.      *
  502.      * @see DB_common::createSequence(), DB_common::getSequenceName(),
  503.      *       DB_sybase::nextID(), DB_sybase::dropSequence()
  504.      */
  505.     function createSequence($seq_name)
  506.     {
  507.         return $this->query('CREATE TABLE '
  508.                             . $this->getSequenceName($seq_name)
  509.                             . ' (id numeric(10, 0) IDENTITY NOT NULL,'
  510.                             . ' vapor int NULL)');
  511.     }
  512.  
  513.     // }}}
  514.     // {{{ dropSequence()
  515.  
  516.     /**
  517.      * Deletes a sequence
  518.      *
  519.      * @param string $seq_name  name of the sequence to be deleted
  520.      *
  521.      * @return int  DB_OK on success.  A DB_Error object on failure.
  522.      *
  523.      * @see DB_common::dropSequence(), DB_common::getSequenceName(),
  524.      *       DB_sybase::nextID(), DB_sybase::createSequence()
  525.      */
  526.     function dropSequence($seq_name)
  527.     {
  528.         return $this->query('DROP TABLE ' $this->getSequenceName($seq_name));
  529.     }
  530.  
  531.     // }}}
  532.     // {{{ quoteFloat()
  533.  
  534.     /**
  535.      * Formats a float value for use within a query in a locale-independent
  536.      * manner.
  537.      *
  538.      * @param float the float value to be quoted.
  539.      * @return string the quoted string.
  540.      * @see DB_common::quoteSmart()
  541.      * @since Method available since release 1.7.8.
  542.      */
  543.     function quoteFloat($float{
  544.         return $this->escapeSimple(str_replace(',''.'strval(floatval($float))));
  545.     }
  546.      
  547.     // }}}
  548.     // {{{ autoCommit()
  549.  
  550.     /**
  551.      * Enables or disables automatic commits
  552.      *
  553.      * @param bool $onoff  true turns it on, false turns it off
  554.      *
  555.      * @return int  DB_OK on success.  A DB_Error object if the driver
  556.      *                doesn't support auto-committing transactions.
  557.      */
  558.     function autoCommit($onoff = false)
  559.     {
  560.         // XXX if $this->transaction_opcount > 0, we should probably
  561.         // issue a warning here.
  562.         $this->autocommit $onoff ? true : false;
  563.         return DB_OK;
  564.     }
  565.  
  566.     // }}}
  567.     // {{{ commit()
  568.  
  569.     /**
  570.      * Commits the current transaction
  571.      *
  572.      * @return int  DB_OK on success.  A DB_Error object on failure.
  573.      */
  574.     function commit()
  575.     {
  576.         if ($this->transaction_opcount > 0{
  577.             if ($this->_db && !@sybase_select_db($this->_db$this->connection)) {
  578.                 return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
  579.             }
  580.             $result @sybase_query('COMMIT'$this->connection);
  581.             $this->transaction_opcount = 0;
  582.             if (!$result{
  583.                 return $this->sybaseRaiseError();
  584.             }
  585.         }
  586.         return DB_OK;
  587.     }
  588.  
  589.     // }}}
  590.     // {{{ rollback()
  591.  
  592.     /**
  593.      * Reverts the current transaction
  594.      *
  595.      * @return int  DB_OK on success.  A DB_Error object on failure.
  596.      */
  597.     function rollback()
  598.     {
  599.         if ($this->transaction_opcount > 0{
  600.             if ($this->_db && !@sybase_select_db($this->_db$this->connection)) {
  601.                 return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
  602.             }
  603.             $result @sybase_query('ROLLBACK'$this->connection);
  604.             $this->transaction_opcount = 0;
  605.             if (!$result{
  606.                 return $this->sybaseRaiseError();
  607.             }
  608.         }
  609.         return DB_OK;
  610.     }
  611.  
  612.     // }}}
  613.     // {{{ sybaseRaiseError()
  614.  
  615.     /**
  616.      * Produces a DB_Error object regarding the current problem
  617.      *
  618.      * @param int $errno  if the error is being manually raised pass a
  619.      *                      DB_ERROR* constant here.  If this isn't passed
  620.      *                      the error information gathered from the DBMS.
  621.      *
  622.      * @return object  the DB_Error object
  623.      *
  624.      * @see DB_common::raiseError(),
  625.      *       DB_sybase::errorNative(), DB_sybase::errorCode()
  626.      */
  627.     function sybaseRaiseError($errno = null)
  628.     {
  629.         $native $this->errorNative();
  630.         if ($errno === null{
  631.             $errno $this->errorCode($native);
  632.         }
  633.         return $this->raiseError($errnonullnullnull$native);
  634.     }
  635.  
  636.     // }}}
  637.     // {{{ errorNative()
  638.  
  639.     /**
  640.      * Gets the DBMS' native error message produced by the last query
  641.      *
  642.      * @return string  the DBMS' error message
  643.      */
  644.     function errorNative()
  645.     {
  646.         return @sybase_get_last_message();
  647.     }
  648.  
  649.     // }}}
  650.     // {{{ errorCode()
  651.  
  652.     /**
  653.      * Determines PEAR::DB error code from the database's text error message.
  654.      *
  655.      * @param  string  $errormsg  error message returned from the database
  656.      * @return integer  an error number from a DB error constant
  657.      */
  658.     function errorCode($errormsg)
  659.     {
  660.         static $error_regexps;
  661.         
  662.         // PHP 5.2+ prepends the function name to $php_errormsg, so we need
  663.         // this hack to work around it, per bug #9599.
  664.         $errormsg preg_replace('/^sybase[a-z_]+\(\): /'''$errormsg);
  665.         
  666.         if (!isset($error_regexps)) {
  667.             $error_regexps = array(
  668.                 '/Incorrect syntax near/'
  669.                     => DB_ERROR_SYNTAX,
  670.                 '/^Unclosed quote before the character string [\"\'].*[\"\']\./'
  671.                     => DB_ERROR_SYNTAX,
  672.                 '/Implicit conversion (from datatype|of NUMERIC value)/i'
  673.                     => DB_ERROR_INVALID_NUMBER,
  674.                 '/Cannot drop the table [\"\'].+[\"\'], because it doesn\'t exist in the system catalogs\./'
  675.                     => DB_ERROR_NOSUCHTABLE,
  676.                 '/Only the owner of object [\"\'].+[\"\'] or a user with System Administrator \(SA\) role can run this command\./'
  677.                     => DB_ERROR_ACCESS_VIOLATION,
  678.                 '/^.+ permission denied on object .+, database .+, owner .+/'
  679.                     => DB_ERROR_ACCESS_VIOLATION,
  680.                 '/^.* permission denied, database .+, owner .+/'
  681.                     => DB_ERROR_ACCESS_VIOLATION,
  682.                 '/[^.*] not found\./'
  683.                     => DB_ERROR_NOSUCHTABLE,
  684.                 '/There is already an object named/'
  685.                     => DB_ERROR_ALREADY_EXISTS,
  686.                 '/Invalid column name/'
  687.                     => DB_ERROR_NOSUCHFIELD,
  688.                 '/does not allow null values/'
  689.                     => DB_ERROR_CONSTRAINT_NOT_NULL,
  690.                 '/Command has been aborted/'
  691.                     => DB_ERROR_CONSTRAINT,
  692.                 '/^Cannot drop the index .* because it doesn\'t exist/i'
  693.                     => DB_ERROR_NOT_FOUND,
  694.                 '/^There is already an index/i'
  695.                     => DB_ERROR_ALREADY_EXISTS,
  696.                 '/^There are fewer columns in the INSERT statement than values specified/i'
  697.                     => DB_ERROR_VALUE_COUNT_ON_ROW,
  698.                 '/Divide by zero/i'
  699.                     => DB_ERROR_DIVZERO,
  700.             );
  701.         }
  702.  
  703.         foreach ($error_regexps as $regexp => $code{
  704.             if (preg_match($regexp$errormsg)) {
  705.                 return $code;
  706.             }
  707.         }
  708.         return DB_ERROR;
  709.     }
  710.  
  711.     // }}}
  712.     // {{{ tableInfo()
  713.  
  714.     /**
  715.      * Returns information about a table or a result set
  716.      *
  717.      * NOTE: only supports 'table' and 'flags' if <var>$result</var>
  718.      * is a table name.
  719.      *
  720.      * @param object|string $result  DB_result object from a query or a
  721.      *                                  string containing the name of a table.
  722.      *                                  While this also accepts a query result
  723.      *                                  resource identifier, this behavior is
  724.      *                                  deprecated.
  725.      * @param int            $mode    a valid tableInfo mode
  726.      *
  727.      * @return array  an associative array with the information requested.
  728.      *                  A DB_Error object on failure.
  729.      *
  730.      * @see DB_common::tableInfo()
  731.      * @since Method available since Release 1.6.0
  732.      */
  733.     function tableInfo($result$mode = null)
  734.     {
  735.         if (is_string($result)) {
  736.             /*
  737.              * Probably received a table name.
  738.              * Create a result resource identifier.
  739.              */
  740.             if ($this->_db && !@sybase_select_db($this->_db$this->connection)) {
  741.                 return $this->sybaseRaiseError(DB_ERROR_NODBSELECTED);
  742.             }
  743.             $id @sybase_query("SELECT * FROM $result WHERE 1=0",
  744.                                 $this->connection);
  745.             $got_string = true;
  746.         elseif (isset($result->result)) {
  747.             /*
  748.              * Probably received a result object.
  749.              * Extract the result resource identifier.
  750.              */
  751.             $id $result->result;
  752.             $got_string = false;
  753.         else {
  754.             /*
  755.              * Probably received a result resource identifier.
  756.              * Copy it.
  757.              * Deprecated.  Here for compatibility only.
  758.              */
  759.             $id $result;
  760.             $got_string = false;
  761.         }
  762.  
  763.         if (!is_resource($id)) {
  764.             return $this->sybaseRaiseError(DB_ERROR_NEED_MORE_DATA);
  765.         }
  766.  
  767.         if ($this->options['portability'DB_PORTABILITY_LOWERCASE{
  768.             $case_func 'strtolower';
  769.         else {
  770.             $case_func 'strval';
  771.         }
  772.  
  773.         $count @sybase_num_fields($id);
  774.         $res   = array();
  775.  
  776.         if ($mode{
  777.             $res['num_fields'$count;
  778.         }
  779.  
  780.         for ($i = 0; $i $count$i++{
  781.             $f @sybase_fetch_field($id$i);
  782.             // column_source is often blank
  783.             $res[$i= array(
  784.                 'table' => $got_string
  785.                            ? $case_func($result)
  786.                            : $case_func($f->column_source),
  787.                 'name'  => $case_func($f->name),
  788.                 'type'  => $f->type,
  789.                 'len'   => $f->max_length,
  790.                 'flags' => '',
  791.             );
  792.             if ($res[$i]['table']{
  793.                 $res[$i]['flags'$this->_sybase_field_flags(
  794.                         $res[$i]['table']$res[$i]['name']);
  795.             }
  796.             if ($mode DB_TABLEINFO_ORDER{
  797.                 $res['order'][$res[$i]['name']] $i;
  798.             }
  799.             if ($mode DB_TABLEINFO_ORDERTABLE{
  800.                 $res['ordertable'][$res[$i]['table']][$res[$i]['name']] $i;
  801.             }
  802.         }
  803.  
  804.         // free the result only if we were called on a table
  805.         if ($got_string{
  806.             @sybase_free_result($id);
  807.         }
  808.         return $res;
  809.     }
  810.  
  811.     // }}}
  812.     // {{{ _sybase_field_flags()
  813.  
  814.     /**
  815.      * Get the flags for a field
  816.      *
  817.      * Currently supports:
  818.      *  + <samp>unique_key</samp>    (unique index, unique check or primary_key)
  819.      *  + <samp>multiple_key</samp>  (multi-key index)
  820.      *
  821.      * @param string  $table   the table name
  822.      * @param string  $column  the field name
  823.      *
  824.      * @return string  space delimited string of flags.  Empty string if none.
  825.      *
  826.      * @access private
  827.      */
  828.     function _sybase_field_flags($table$column)
  829.     {
  830.         static $tableName = null;
  831.         static $flags = array();
  832.  
  833.         if ($table != $tableName{
  834.             $flags = array();
  835.             $tableName $table;
  836.  
  837.             /* We're running sp_helpindex directly because it doesn't exist in
  838.              * older versions of ASE -- unfortunately, we can't just use
  839.              * DB::isError() because the user may be using callback error
  840.              * handling. */
  841.             $res @sybase_query("sp_helpindex $table"$this->connection);
  842.  
  843.             if ($res === false || $res === true{
  844.                 // Fake a valid response for BC reasons.
  845.                 return '';
  846.             }
  847.  
  848.             while (($val = sybase_fetch_assoc($res)) !== false{
  849.                 if (!isset($val['index_keys'])) {
  850.                     /* No useful information returned. Break and be done with
  851.                      * it, which preserves the pre-1.7.9 behaviour. */
  852.                     break;
  853.                 }
  854.  
  855.                 $keys explode(', 'trim($val['index_keys']));
  856.  
  857.                 if (sizeof($keys> 1{
  858.                     foreach ($keys as $key{
  859.                         $this->_add_flag($flags[$key]'multiple_key');
  860.                     }
  861.                 }
  862.  
  863.                 if (strpos($val['index_description']'unique')) {
  864.                     foreach ($keys as $key{
  865.                         $this->_add_flag($flags[$key]'unique_key');
  866.                     }
  867.                 }
  868.             }
  869.  
  870.             sybase_free_result($res);
  871.  
  872.         }
  873.  
  874.         if (array_key_exists($column$flags)) {
  875.             return(implode(' '$flags[$column]));
  876.         }
  877.  
  878.         return '';
  879.     }
  880.  
  881.     // }}}
  882.     // {{{ _add_flag()
  883.  
  884.     /**
  885.      * Adds a string to the flags array if the flag is not yet in there
  886.      * - if there is no flag present the array is created
  887.      *
  888.      * @param array  $array  reference of flags array to add a value to
  889.      * @param mixed  $value  value to add to the flag array
  890.      *
  891.      * @return void 
  892.      *
  893.      * @access private
  894.      */
  895.     function _add_flag(&$array$value)
  896.     {
  897.         if (!is_array($array)) {
  898.             $array = array($value);
  899.         elseif (!in_array($value$array)) {
  900.             array_push($array$value);
  901.         }
  902.     }
  903.  
  904.     // }}}
  905.     // {{{ getSpecialQuery()
  906.  
  907.     /**
  908.      * Obtains the query string needed for listing a given type of objects
  909.      *
  910.      * @param string $type  the kind of objects you want to retrieve
  911.      *
  912.      * @return string  the SQL query string or null if the driver doesn't
  913.      *                   support the object type requested
  914.      *
  915.      * @access protected
  916.      * @see DB_common::getListOf()
  917.      */
  918.     function getSpecialQuery($type)
  919.     {
  920.         switch ($type{
  921.             case 'tables':
  922.                 return "SELECT name FROM sysobjects WHERE type = 'U'"
  923.                        . ' ORDER BY name';
  924.             case 'views':
  925.                 return "SELECT name FROM sysobjects WHERE type = 'V'";
  926.             default:
  927.                 return null;
  928.         }
  929.     }
  930.  
  931.     // }}}
  932.  
  933. }
  934.  
  935. /*
  936.  * Local variables:
  937.  * tab-width: 4
  938.  * c-basic-offset: 4
  939.  * End:
  940.  */
  941.  
  942. ?>

Documentation generated on Sat, 27 Aug 2011 14:00:20 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.