home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / php / pear / DB / common.php next >
PHP Script  |  2001-03-12  |  24KB  |  871 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. // Base class for DB implementations.
  21. //
  22.  
  23. /**
  24.  * DB_common is a base class for DB implementations, and must be
  25.  * inherited by all such.
  26.  */
  27.  
  28. class DB_common
  29. {
  30.     // {{{ properties
  31.  
  32.     var $features;      // assoc of capabilities for this DB implementation
  33.     var $errorcode_map; // assoc mapping native error codes to DB ones
  34.     var $type;          // DB type (mysql, oci8, odbc etc.)
  35.     var $prepare_tokens;
  36.     var $prepare_types;
  37.     var $prepare_maxstmt;
  38.     var $error_mode = PEAR_ERROR_RETURN;
  39.     var $error_level = E_USER_NOTICE;
  40.     var $error_callback;
  41.     var $last_query = '';
  42.     var $fetchmode = DB_FETCHMODE_ORDERED;
  43.     var $options = array(
  44.         'persistent' => false,       // persistent connection?
  45.         'optimize' => 'performance', // 'performance' or 'portability'
  46.     );
  47.     var $dbh;
  48.  
  49.     // }}}
  50.     // {{{ toString()
  51.  
  52.     function toString()
  53.     {
  54.     $info = get_class($this);
  55.         
  56.     $info .=  ": (phptype=" . $this->phptype .
  57.                   ", dbsyntax=" . $this->dbsyntax .
  58.                   ")";
  59.  
  60.         if ($this->connection) {
  61.             $info .= " [connected]";
  62.         }
  63.  
  64.         return $info;
  65.     }
  66.  
  67.     // }}}
  68.     // {{{ constructor
  69.  
  70.     function DB_common()
  71.     {
  72.         $this->features = array();
  73.         $this->errorcode_map = array();
  74.         $this->fetchmode = DB_FETCHMODE_ORDERED;
  75.     }
  76.  
  77.     // }}}
  78.     // {{{ quoteString()
  79.  
  80.     /**
  81.      * Quotes a string so it can be safely used within string delimiters
  82.      * in a query.
  83.      *
  84.      * @param $string the input string to quote
  85.      *
  86.      * @return string the quoted string
  87.      */
  88.  
  89.     function quoteString($string)
  90.     {
  91.         return str_replace("'", "\'", $string);
  92.     }
  93.  
  94.     // }}}
  95.     // {{{ provides()
  96.  
  97.     /**
  98.      * Tell whether a DB implementation or its backend extension
  99.      * supports a given feature.
  100.      *
  101.      * @param $feature name of the feature (see the DB class doc)
  102.      *
  103.      * @return bool whether this DB implementation supports $feature
  104.      */
  105.  
  106.     function provides($feature)
  107.     {
  108.         return $this->features[$feature];
  109.     }
  110.  
  111.     // }}}
  112.     // {{{ errorCode()
  113.  
  114.     /**
  115.      * Map native error codes to DB's portable ones.  Requires that
  116.      * the DB implementation's constructor fills in the $errorcode_map
  117.      * property.
  118.      *
  119.      * @param $nativecode the native error code, as returned by the backend
  120.      * database extension (string or integer)
  121.      *
  122.      * @return int a portable DB error code, or FALSE if this DB
  123.      * implementation has no mapping for the given error code.
  124.      */
  125.  
  126.     function errorCode($nativecode)
  127.     {
  128.         if ($this->errorcode_map[$nativecode]) {
  129.             return $this->errorcode_map[$nativecode];
  130.         }
  131.  
  132.         //php_error(E_WARNING, get_class($this)."::errorCode: no mapping for $nativecode");
  133.         // Fall back to DB_ERROR if there was no mapping.
  134.  
  135.         return DB_ERROR;
  136.     }
  137.  
  138.     // }}}
  139.     // {{{ errorMessage()
  140.  
  141.     /**
  142.      * Map a DB error code to a textual message.  This is actually
  143.      * just a wrapper for DB::errorMessage().
  144.      *
  145.      * @param $dbcode the DB error code
  146.      *
  147.      * @return string the corresponding error message, of FALSE
  148.      * if the error code was unknown
  149.      */
  150.  
  151.     function errorMessage($dbcode)
  152.     {
  153.         return DB::errorMessage($this->errorcode_map[$dbcode]);
  154.     }
  155.  
  156.     // }}}
  157.     // {{{ raiseError()
  158.  
  159.     /**
  160.      * This method is called by DB to generate an error.
  161.      *
  162.      */
  163.  
  164.     function &raiseError($code = DB_ERROR, $mode = false, $level = false,
  165.                          $debuginfo = false, $nativecode = false)
  166.     {
  167.         if (!$mode) {
  168.             $mode = $this->error_mode;
  169.         }
  170.  
  171.         if ($mode == PEAR_ERROR_CALLBACK) {
  172.             if (!is_string($level) &&
  173.                 !(is_array($level) && sizeof($level) == 2 &&
  174.                   is_object($level[0]) && is_string($level[1]))) {
  175.                 $level = $this->error_callback;
  176.             }
  177.         } else {
  178.             if (!$level) {
  179.                 $level = $this->error_level;
  180.             }
  181.         }
  182.  
  183.         if (!$debuginfo) {
  184.             $debuginfo = $this->last_query;
  185.         }
  186.  
  187.         if ($nativecode) {
  188.             $debuginfo .= " [nativecode=$nativecode]";
  189.         }
  190.  
  191.         return new DB_Error($code, $mode, $level, $debuginfo);
  192.     }
  193.  
  194.     // }}}
  195.     // {{{ setErrorHandling()
  196.  
  197.     /**
  198.      * Sets how errors generated by this DB object should be handled.
  199.      *
  200.      * @param $mode int
  201.      *        one of PEAR_ERROR_RETURN, PEAR_ERROR_PRINT,
  202.      *        PEAR_ERROR_TRIGGER, PEAR_ERROR_DIE or
  203.      *        PEAR_ERROR_CALLBACK.
  204.      *
  205.      * @param $options mixed
  206.      *        Ignored unless $mode is PEAR_ERROR_TRIGGER or
  207.      *        PEAR_ERROR_CALLBACK.  When $mode is PEAR_ERROR_TRIGGER,
  208.      *        this parameter is expected to be an integer among
  209.      *        E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR.  When
  210.      *        $mode is PEAR_ERROR_CALLBACK, this parameter is expected
  211.      *        to be the callback function or method.  A callback
  212.      *        function is a string with the name of the function, a
  213.      *        callback method is an array of two elements: the element
  214.      *        at index 0 is an object, and the element at index 1 is
  215.      *        the name of the method to call in the object.
  216.      *
  217.      * @see PEAR_ERROR_RETURN
  218.      * @see PEAR_ERROR_PRINT
  219.      * @see PEAR_ERROR_TRIGGER
  220.      * @see PEAR_ERROR_DIE
  221.      * @see PEAR_ERROR_CALLBACK
  222.      */
  223.  
  224.     function setErrorHandling($mode, $options = false)
  225.     {
  226.         switch ($mode) {
  227.             case PEAR_ERROR_RETURN:
  228.             case PEAR_ERROR_PRINT:
  229.             case PEAR_ERROR_TRIGGER:
  230.             case PEAR_ERROR_DIE:
  231.                 $this->error_mode = $mode;
  232.                 
  233.                 if (!$options) {
  234.                     $this->error_level = E_USER_NOTICE;
  235.                 } else {
  236.                     $this->error_level = $options;
  237.                 }
  238.                 break;
  239.  
  240.             case PEAR_ERROR_CALLBACK:
  241.                 $this->error_mode = $mode;
  242.                 if (is_string($options) ||
  243.                     (is_array($options) && sizeof($options) == 2 &&
  244.                      is_object($options[0]) && is_string($options[1]))) {
  245.                     $this->error_callback = $options;
  246.                 } else {
  247.                     trigger_error("invalid error callback", E_USER_WARNING);
  248.                 }
  249.                 $this->error_level = PEAR_ERROR_RETURN;
  250.                 break;
  251.  
  252.             default:
  253.                 trigger_error("invalid error mode", E_USER_WARNING);
  254.                 break;
  255.         }
  256.     }
  257.  
  258.     // }}}
  259.     // {{{ setFetchMode()
  260.  
  261.     /**
  262.      * Sets which fetch mode should be used by default on queries
  263.      * on this connection.
  264.      *
  265.      * @param $fetchmode int DB_FETCHMODE_ORDERED or
  266.      *        DB_FETCHMODE_ASSOC, possibly bit-wise OR'ed with
  267.      *        DB_FETCHMODE_FLIPPED.
  268.      *
  269.      * @see DB_FETCHMODE_ORDERED
  270.      * @see DB_FETCHMODE_ASSOC
  271.      * @see DB_FETCHMODE_FLIPPED
  272.      */
  273.  
  274.     function setFetchMode($fetchmode)
  275.     {
  276.         switch ($fetchmode) {
  277.             case DB_FETCHMODE_ORDERED:
  278.             case DB_FETCHMODE_ASSOC:
  279.                 $this->fetchmode = $fetchmode;
  280.                 break;
  281.             default:
  282.                 return $this->raiseError("invalid get mode");
  283.         }
  284.     }
  285.  
  286.     // }}}
  287.     // {{{ setOption()
  288.  
  289.     function setOption($option, $value)
  290.     {
  291.         if (isset($this->options[$option])) {
  292.             $this->options[$option] = $value;
  293.             return DB_OK;
  294.         }
  295.         return $this->raiseError("unknown option $option");
  296.     }
  297.  
  298.     // }}}
  299.     // {{{ getOption()
  300.  
  301.     function getOption($option)
  302.     {
  303.         if (isset($this->options[$option])) {
  304.             return $this->options[$option];
  305.         }
  306.         return $this->raiseError("unknown option $option");
  307.     }
  308.  
  309.     // }}}
  310.     // {{{ prepare()
  311.  
  312.     /**
  313.      * Prepares a query for multiple execution with execute().  With
  314.      * some database backends, this is emulated.
  315.      */
  316.  
  317.     function prepare($query)
  318.     {
  319.         $tokens = split("[\&\?]", $query);
  320.         $token = 0;
  321.         $types = array();
  322.  
  323.         for ($i = 0; $i < strlen($query); $i++) {
  324.             switch ($query[$i]) {
  325.                 case "?":
  326.                     $types[$token++] = DB_PARAM_SCALAR;
  327.                     break;
  328.                 case "&":
  329.                     $types[$token++] = DB_PARAM_OPAQUE;
  330.                     break;
  331.             }
  332.         }
  333.  
  334.         $this->prepare_tokens[] = &$tokens;
  335.         end($this->prepare_tokens);
  336.  
  337.         $k = key($this->prepare_tokens);
  338.         $this->prepare_types[$k] = $types;
  339.  
  340.         return $k;
  341.     }
  342.  
  343.     // }}}
  344.     // {{{ execute()
  345.  
  346.     function execute($stmt, $data = false)
  347.     {
  348.         $realquery = $this->executeEmulateQuery($stmt, $data);
  349.         $result = $this->simpleQuery($realquery);
  350.         if (DB::isError($result) || $result === DB_OK) {
  351.             return $result;
  352.         } else {
  353.             return new DB_result($this, $result);
  354.         }
  355.     }
  356.  
  357.     // }}}
  358.     // {{{ executeEmulateQuery()
  359.  
  360.     /**
  361.      * @return a string containing the real query run when emulating
  362.      * prepare/execute.  A DB error code is returned on failure.
  363.      */
  364.  
  365.     function executeEmulateQuery($stmt, $data = false)
  366.     {
  367.         $p = &$this->prepare_tokens;
  368.         $stmt = (int)$this->prepare_maxstmt++;
  369.  
  370.         if (!isset($this->prepare_tokens[$stmt]) ||
  371.             !is_array($this->prepare_tokens[$stmt]) ||
  372.             !sizeof($this->prepare_tokens[$stmt])) {
  373.             return $this->raiseError(DB_ERROR_INVALID);
  374.         }
  375.         
  376.         $qq = &$this->prepare_tokens[$stmt];
  377.         $qp = sizeof($qq) - 1;
  378.         
  379.         if ((!$data && $qp > 0) ||
  380.             (!is_array($data) && $qp > 1) ||
  381.             (is_array($data) && $qp > sizeof($data))) {
  382.             return $this->raiseError(DB_ERROR_NEED_MORE_DATA);
  383.         }
  384.         
  385.         $realquery = $qq[0];
  386.         
  387.         for ($i = 0; $i < $qp; $i++) {
  388.             if ($this->prepare_types[$stmt][$i] == DB_PARAM_OPAQUE) {
  389.                 if (is_array($data)) {
  390.                     $fp = fopen($data[$i], "r");
  391.                 } else {
  392.                     $fp = fopen($data, "r");
  393.                 }
  394.  
  395.                 $pdata = "";
  396.  
  397.                 if ($fp) {
  398.                     while (($buf = fread($fp, 4096)) != false) {
  399.                         $pdata .= $buf;
  400.                     }
  401.                 }
  402.             } else {
  403.                 if (is_array($data)) {
  404.                     $pdata = &$data[$i];
  405.                 } else {
  406.                     $pdata = &$data;
  407.                 }
  408.             }
  409.  
  410.             $realquery .= "'" . $this->quoteString($pdata) . "'";
  411.             $realquery .= $qq[$i + 1];
  412.         }
  413.  
  414.         return $realquery;
  415.     }
  416.  
  417.     // }}}
  418.     // {{{ executeMultiple()
  419.  
  420.     /**
  421.      * This function does several execute() calls on the same
  422.      * statement handle.  $data must be an array indexed numerically
  423.      * from 0, one execute call is done for every "row" in the array.
  424.      *
  425.      * If an error occurs during execute(), executeMultiple() does not
  426.      * execute the unfinished rows, but rather returns that error.
  427.      */
  428.  
  429.     function executeMultiple( $stmt, &$data )
  430.     {
  431.         for($i = 0; $i < sizeof( $data ); $i++) {
  432.             $res = $this->execute($stmt, $data[$i]);
  433.             if (DB::isError($res)) {
  434.                 return $res;
  435.             }
  436.         }
  437.         return DB_OK;
  438.     }
  439.  
  440.     // }}}
  441.     // {{{ modifyQuery()
  442.  
  443.     /**
  444.      * This method is used by backends to alter queries for various
  445.      * reasons.  It is defined here to assure that all implementations
  446.      * have this method defined.
  447.      *
  448.      * @access private
  449.      *
  450.      * @param query to modify
  451.      *
  452.      * @return the new (modified) query
  453.      */
  454.     function modifyQuery($query) {
  455.         return $query;
  456.     }
  457.  
  458.     // }}}
  459.     // {{{ query()
  460.  
  461.     /**
  462.      * Send a query to the database and return any results with a
  463.      * DB_result object.
  464.      *
  465.      * @access public
  466.      *
  467.      * @param the SQL query
  468.      *
  469.      * @return object a DB_result object or DB_OK on success, a DB
  470.      * error on failure
  471.      *
  472.      * @see DB::isError
  473.      */
  474.     function &query($query) {
  475.         $result = $this->simpleQuery($query);
  476.         if (DB::isError($result) || $result === DB_OK) {
  477.             return $result;
  478.         } else {
  479.             return new DB_result($this, $result);
  480.         }
  481.     }
  482.  
  483.     // }}}
  484.     // {{{ getOne()
  485.  
  486.     /**
  487.      * Fetch the first column of the first row of data returned from
  488.      * a query.  Takes care of doing the query and freeing the results
  489.      * when finished.
  490.      *
  491.      * @param $query the SQL query
  492.      * @param $params if supplied, prepare/execute will be used
  493.      *        with this array as execute parameters
  494.      * @access public
  495.      */
  496.  
  497.     function &getOne($query, $params = array())
  498.     {
  499.         if (sizeof($params) > 0) {
  500.             $sth = $this->prepare($query);
  501.  
  502.             if (DB::isError($sth)) {
  503.                 return $sth;
  504.             }
  505.             $res = $this->execute($sth, $params);
  506.         } else {
  507.             $res = $this->simpleQuery($query);
  508.         }
  509.  
  510.         if (DB::isError($res)) {
  511.             return $res;
  512.         }
  513.  
  514.         $row = $this->fetchRow($res, DB_FETCHMODE_ORDERED);
  515.  
  516.         if (DB::isError($row)) {
  517.             return $row;
  518.         }
  519.  
  520.         $ret = &$row[0];
  521.         $this->freeResult($res);
  522.  
  523.         if (isset($sth)) {
  524.             $this->freeResult($sth);
  525.         }
  526.  
  527.         return $ret;
  528.     }
  529.  
  530.     // }}}
  531.     // {{{ getRow()
  532.  
  533.     /**
  534.      * Fetch the first row of data returned from a query.  Takes care
  535.      * of doing the query and freeing the results when finished.
  536.      *
  537.      * @param $query the SQL query
  538.      * @access public
  539.      * @return array the first row of results as an array indexed from
  540.      * 0, or a DB error code.
  541.      */
  542.  
  543.     function &getRow($query, $fetchmode = DB_FETCHMODE_DEFAULT,
  544.                      $params = array())
  545.     {
  546.         if ($fetchmode == DB_FETCHMODE_DEFAULT) {
  547.             $fetchmode = $this->fetchmode;
  548.         }
  549.  
  550.         if (sizeof($params) > 0) {
  551.             $sth = $this->prepare( $query );
  552.             if (DB::isError($sth)) {
  553.                 return $sth;
  554.             }
  555.             $res = $this->execute($sth, $params);
  556.         } else {
  557.             $res = $this->simpleQuery($query);
  558.         }
  559.  
  560.         if (DB::isError($res)) {
  561.             return $res;
  562.         }
  563.  
  564.         $row = $this->fetchRow($res, $fetchmode);
  565.  
  566.         if (DB::isError($row)) {
  567.             return $row;
  568.         }
  569.  
  570.         $this->freeResult($res);
  571.  
  572.         if (isset($sth)) {
  573.             $this->freeResult($sth);
  574.         }
  575.  
  576.         return $row;
  577.     }
  578.  
  579.     // }}}
  580.     // {{{ getCol()
  581.  
  582.     /**
  583.      * Fetch a single column from a result set and return it as an
  584.      * indexed array.
  585.      *
  586.      * @param $query the SQL query
  587.      *
  588.      * @param $col which column to return (integer [column number,
  589.      * starting at 0] or string [column name])
  590.      *
  591.      * @access public
  592.      *
  593.      * @return array an indexed array with the data from the first
  594.      * row at index 0, or a DB error code.
  595.      */
  596.  
  597.     function &getCol($query, $col = 0, $params = array())
  598.     {
  599.         if (sizeof($params) > 0) {
  600.             $sth = $this->prepare($query);
  601.  
  602.             if (DB::isError($sth)) {
  603.                 return $sth;
  604.             }
  605.  
  606.             $res = $this->execute($sth, $params);
  607.         } else {
  608.             $res = $this->simpleQuery($query);
  609.         }
  610.  
  611.         if (DB::isError($res)) {
  612.             return $res;
  613.         }
  614.  
  615.         $fetchmode = is_int($col) ? DB_FETCHMODE_ORDERED : DB_FETCHMODE_ASSOC;
  616.         $ret = array();
  617.  
  618.         while ($row = $this->fetchRow($res, $fetchmode)) {
  619.             if (DB::isError($row)) {
  620.                 $ret = $row;
  621.                 break;
  622.             }
  623.  
  624.             $ret[] = $row[$col];
  625.         }
  626.  
  627.         $this->freeResult($res);
  628.  
  629.         if (isset($sth)) {
  630.             $this->freeResult($sth);
  631.         }
  632.  
  633.         return $ret;
  634.     }
  635.  
  636.     // }}}
  637.     // {{{ getAssoc()
  638.  
  639.     /**
  640.      * Fetch the entire result set of a query and return it as an
  641.      * associative array using the first column as the key.
  642.      *
  643.      * @param $query the SQL query
  644.      *
  645.      * @param $force_array (optional) used only when the query returns
  646.      * exactly two columns.  If true, the values of the returned array
  647.      * will be one-element arrays instead of scalars.
  648.      *
  649.      * @access public
  650.      *
  651.      * @return array associative array with results from the query.
  652.      * If the result set contains more than two columns, the value
  653.      * will be an array of the values from column 2-n.  If the result
  654.      * set contains only two columns, the returned value will be a
  655.      * scalar with the value of the second column (unless forced to an
  656.      * array with the $force_array parameter).  A DB error code is
  657.      * returned on errors.  If the result set contains fewer than two
  658.      * columns, a DB_ERROR_TRUNCATED error is returned.
  659.      *
  660.      * For example, if the table "mytable" contains:
  661.      *
  662.      *  ID      TEXT       DATE
  663.      * --------------------------------
  664.      *  1       'one'      944679408
  665.      *  2       'two'      944679408
  666.      *  3       'three'    944679408
  667.      *
  668.      * Then the call getAssoc('SELECT id,text FROM mytable') returns:
  669.      *   array(
  670.      *     '1' => 'one',
  671.      *     '2' => 'two',
  672.      *     '3' => 'three',
  673.      *  )
  674.      *
  675.      * ...while the call getAssoc('SELECT id,text,date FROM mydate') returns:
  676.      *   array(
  677.      *     '1' => array('one', '944679408'),
  678.      *     '2' => array('two', '944679408'),
  679.      *     '3' => array('three', '944679408')
  680.      *  )
  681.      *
  682.      * Keep in mind that database functions in PHP usually return string
  683.      * values for results regardless of the database's internal type.
  684.      */
  685.  
  686.     function &getAssoc($query, $force_array = false, $params = array())
  687.     {
  688.         if (sizeof($params) > 0) {
  689.             $sth = $this->prepare($query);
  690.  
  691.             if (DB::isError($sth)) {
  692.                 return $sth;
  693.             }
  694.  
  695.             $res = $this->execute($sth, $params);
  696.         } else {
  697.             $res = $this->simpleQuery($query);
  698.         }
  699.  
  700.         if (DB::isError($res)) {
  701.             return $res;
  702.         }
  703.  
  704.         $cols = $this->numCols($res);
  705.  
  706.         if ($cols < 2) {
  707.             return $this->raiseError(DB_ERROR_TRUNCATED);
  708.         }
  709.  
  710.         $results = array();
  711.  
  712.         if ($cols > 2 || $force_array) {
  713.             // return array values
  714.             // XXX this part can be optimized
  715.             while (($row = $this->fetchRow($res, DB_FETCHMODE_ORDERED)) &&
  716.                    !DB::isError($row)) {
  717.                 reset($row);
  718.                 // we copy the row of data into a new array
  719.                 // to get indices running from 0 again
  720.                 $results[$row[0]] = array_slice($row, 1);
  721.             }
  722.         } else {
  723.             // return scalar values
  724.             while (($row = $this->fetchRow($res, DB_FETCHMODE_ORDERED)) &&
  725.                    !DB::isError($row)) {
  726.                 $results[$row[0]] = $row[1];
  727.             }
  728.         }
  729.  
  730.         $this->freeResult($res);
  731.  
  732.         if (isset($sth)) {
  733.             $this->freeResult($sth);
  734.         }
  735.  
  736.         return $results;
  737.     }
  738.  
  739.     // }}}
  740.     // {{{ getAll()
  741.  
  742.     /**
  743.      * Fetch all the rows returned from a query.
  744.      *
  745.      * @param $query the SQL query
  746.      * @access public
  747.      * @return array an nested array, or a DB error
  748.      */
  749.  
  750.     function &getAll($query, $fetchmode = DB_FETCHMODE_DEFAULT,
  751.                      $params = array())
  752.     {
  753.         if ($fetchmode == DB_FETCHMODE_DEFAULT) {
  754.             $fetchmode = $this->fetchmode;
  755.         }
  756.  
  757.         if (sizeof($params) > 0) {
  758.             $sth = $this->prepare($query);
  759.  
  760.             if (DB::isError($sth)) {
  761.                 return $sth;
  762.             }
  763.  
  764.             $res = $this->execute($sth, $params);
  765.         } else {
  766.             $res = $this->simpleQuery($query);
  767.         }
  768.  
  769.         if (DB::isError($res)) {
  770.             return $res;
  771.         }
  772.  
  773.         $results = array();
  774.  
  775.         while (($row = $this->fetchRow($res, $fetchmode)) &&
  776.                !DB::isError($row)) {
  777.             if ($fetchmode & DB_FETCHMODE_FLIPPED) {
  778.                 foreach ($row as $key => $val) {
  779.                     $results[$key][] = $val;
  780.                 }
  781.             } else {
  782.                 $results[] = $row;
  783.             }
  784.         }
  785.  
  786.         $this->freeResult($res);
  787.  
  788.         if (isset($sth)) {
  789.             $this->freeResult($sth);
  790.         }
  791.  
  792.         return $results;
  793.     }
  794.  
  795.     // }}}
  796.     // {{{ autoCommit()
  797.  
  798.     function autoCommit($onoff=false)
  799.     {
  800.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  801.     }
  802.  
  803.     // }}}
  804.     // {{{ commit()
  805.  
  806.     function commit()
  807.     {
  808.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  809.     }
  810.  
  811.     // }}}
  812.     // {{{ rollback()
  813.  
  814.     function rollback()
  815.     {
  816.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  817.     }
  818.  
  819.     // }}}
  820.     // {{{ numRows()
  821.  
  822.     function numRows($result)
  823.     {
  824.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  825.     }
  826.  
  827.     // }}}
  828.     // {{{ affectedRows()
  829.  
  830.     function affectedRows()
  831.     {
  832.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  833.     }
  834.  
  835.     // }}}
  836.     // {{{ errorNative()
  837.  
  838.     function errorNative()
  839.     {
  840.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  841.     }
  842.  
  843.     // }}}
  844.     // {{{ nextId()
  845.  
  846.     function nextId($seq_name, $ondemand = true)
  847.     {
  848.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  849.     }
  850.  
  851.     // }}}
  852.     // {{{ createSequence()
  853.  
  854.     function createSequence($seq_name)
  855.     {
  856.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  857.     }
  858.  
  859.     // }}}
  860.     // {{{ dropSequence()
  861.  
  862.     function dropSequence($seq_name)
  863.     {
  864.         return $this->raiseError(DB_ERROR_NOT_CAPABLE);
  865.     }
  866.  
  867.     // }}}
  868. }
  869.  
  870. ?>
  871.