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

Source for file Extended.php

Documentation is available at Extended.php

  1. <?php
  2. // +----------------------------------------------------------------------+
  3. // | PHP versions 4 and 5                                                 |
  4. // +----------------------------------------------------------------------+
  5. // | Copyright (c) 1998-2006 Manuel Lemos, Tomas V.V.Cox,                 |
  6. // | Stig. S. Bakken, Lukas Smith                                         |
  7. // | All rights reserved.                                                 |
  8. // +----------------------------------------------------------------------+
  9. // | MDB2 is a merge of PEAR DB and Metabases that provides a unified DB  |
  10. // | API as well as database abstraction for PHP applications.            |
  11. // | This LICENSE is in the BSD license style.                            |
  12. // |                                                                      |
  13. // | Redistribution and use in source and binary forms, with or without   |
  14. // | modification, are permitted provided that the following conditions   |
  15. // | are met:                                                             |
  16. // |                                                                      |
  17. // | Redistributions of source code must retain the above copyright       |
  18. // | notice, this list of conditions and the following disclaimer.        |
  19. // |                                                                      |
  20. // | Redistributions in binary form must reproduce the above copyright    |
  21. // | notice, this list of conditions and the following disclaimer in the  |
  22. // | documentation and/or other materials provided with the distribution. |
  23. // |                                                                      |
  24. // | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken,    |
  25. // | Lukas Smith nor the names of his contributors may be used to endorse |
  26. // | or promote products derived from this software without specific prior|
  27. // | written permission.                                                  |
  28. // |                                                                      |
  29. // | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS  |
  30. // | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT    |
  31. // | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS    |
  32. // | FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE      |
  33. // | REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,          |
  34. // | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
  35. // | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS|
  36. // |  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED  |
  37. // | AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT          |
  38. // | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY|
  39. // | WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE          |
  40. // | POSSIBILITY OF SUCH DAMAGE.                                          |
  41. // +----------------------------------------------------------------------+
  42. // | Author: Lukas Smith <smith@pooteeweet.org>                           |
  43. // +----------------------------------------------------------------------+
  44. //
  45. // $Id: Extended.php 327310 2012-08-27 15:16:18Z danielc $
  46.  
  47. /**
  48.  * @package  MDB2
  49.  * @category Database
  50.  * @author   Lukas Smith <smith@pooteeweet.org>
  51.  */
  52.  
  53. /**
  54.  * Used by autoPrepare()
  55.  */
  56. define('MDB2_AUTOQUERY_INSERT'1);
  57. define('MDB2_AUTOQUERY_UPDATE'2);
  58. define('MDB2_AUTOQUERY_DELETE'3);
  59. define('MDB2_AUTOQUERY_SELECT'4);
  60.  
  61. /**
  62.  * MDB2_Extended: class which adds several high level methods to MDB2
  63.  *
  64.  * @package MDB2
  65.  * @category Database
  66.  * @author Lukas Smith <smith@pooteeweet.org>
  67.  */
  68. {
  69.     // {{{ autoPrepare()
  70.  
  71.     /**
  72.      * Generate an insert, update or delete query and call prepare() on it
  73.      *
  74.      * @param string table
  75.      * @param array the fields names
  76.      * @param int type of query to build
  77.      *                           MDB2_AUTOQUERY_INSERT
  78.      *                           MDB2_AUTOQUERY_UPDATE
  79.      *                           MDB2_AUTOQUERY_DELETE
  80.      *                           MDB2_AUTOQUERY_SELECT
  81.      * @param string (in case of update and delete queries, this string will be put after the sql WHERE statement)
  82.      * @param array that contains the types of the placeholders
  83.      * @param mixed array that contains the types of the columns in
  84.      *                         the result set or MDB2_PREPARE_RESULT, if set to
  85.      *                         MDB2_PREPARE_MANIP the query is handled as a manipulation query
  86.      *
  87.      * @return resource handle for the query
  88.      * @see buildManipSQL
  89.      * @access public
  90.      */
  91.     function autoPrepare($table$table_fields$mode = MDB2_AUTOQUERY_INSERT,
  92.         $where = false$types = null$result_types = MDB2_PREPARE_MANIP)
  93.     {
  94.         $query $this->buildManipSQL($table$table_fields$mode$where);
  95.         if (MDB2::isError($query)) {
  96.             return $query;
  97.         }
  98.         $db $this->getDBInstance();
  99.         if (MDB2::isError($db)) {
  100.             return $db;
  101.         }
  102.         $lobs = array();
  103.         foreach ((array)$types as $param => $type{
  104.             if (($type == 'clob'|| ($type == 'blob')) {
  105.                 $lobs[$param$table_fields[$param];
  106.             }
  107.         }
  108.         return $db->prepare($query$types$result_types$lobs);
  109.     }
  110.  
  111.     // }}}
  112.     // {{{ autoExecute()
  113.  
  114.     /**
  115.      * Generate an insert, update or delete query and call prepare() and execute() on it
  116.      *
  117.      * @param string name of the table
  118.      * @param array assoc ($key=>$value) where $key is a field name and $value its value
  119.      * @param int type of query to build
  120.      *                           MDB2_AUTOQUERY_INSERT
  121.      *                           MDB2_AUTOQUERY_UPDATE
  122.      *                           MDB2_AUTOQUERY_DELETE
  123.      *                           MDB2_AUTOQUERY_SELECT
  124.      * @param string (in case of update and delete queries, this string will be put after the sql WHERE statement)
  125.      * @param array that contains the types of the placeholders
  126.      * @param string which specifies which result class to use
  127.      * @param mixed  array that contains the types of the columns in
  128.      *                         the result set or MDB2_PREPARE_RESULT, if set to
  129.      *                         MDB2_PREPARE_MANIP the query is handled as a manipulation query
  130.      *
  131.      * @return bool|MDB2_Errortrue on success, a MDB2 error on failure
  132.      * @see buildManipSQL
  133.      * @see autoPrepare
  134.      * @access public
  135.     */
  136.     function autoExecute($table$fields_values$mode = MDB2_AUTOQUERY_INSERT,
  137.         $where = false$types = null$result_class = true$result_types = MDB2_PREPARE_MANIP)
  138.     {
  139.         $fields_values = (array)$fields_values;
  140.         if ($mode == MDB2_AUTOQUERY_SELECT{
  141.             if (is_array($result_types)) {
  142.                 $keys array_keys($result_types);
  143.             elseif (!empty($fields_values)) {
  144.                 $keys $fields_values;
  145.             else {
  146.                 $keys = array();
  147.             }
  148.         else {
  149.             $keys array_keys($fields_values);
  150.         }
  151.         $params array_values($fields_values);
  152.         if (empty($params)) {
  153.             $query $this->buildManipSQL($table$keys$mode$where);
  154.  
  155.             $db $this->getDBInstance();
  156.             if (MDB2::isError($db)) {
  157.                 return $db;
  158.             }
  159.             if ($mode == MDB2_AUTOQUERY_SELECT{
  160.                 $result $db->query($query$result_types$result_class);
  161.             else {
  162.                 $result $db->exec($query);
  163.             }
  164.         else {
  165.             $stmt $this->autoPrepare($table$keys$mode$where$types$result_types);
  166.             if (MDB2::isError($stmt)) {
  167.                 return $stmt;
  168.             }
  169.             $result $stmt->execute($params$result_class);
  170.             $stmt->free();
  171.         }
  172.         return $result;
  173.     }
  174.  
  175.     // }}}
  176.     // {{{ buildManipSQL()
  177.  
  178.     /**
  179.      * Make automaticaly an sql query for prepare()
  180.      *
  181.      * Example : buildManipSQL('table_sql', array('field1', 'field2', 'field3'), MDB2_AUTOQUERY_INSERT)
  182.      *           will return the string : INSERT INTO table_sql (field1,field2,field3) VALUES (?,?,?)
  183.      * NB : - This belongs more to a SQL Builder class, but this is a simple facility
  184.      *      - Be carefull ! If you don't give a $where param with an UPDATE/DELETE query, all
  185.      *        the records of the table will be updated/deleted !
  186.      *
  187.      * @param string name of the table
  188.      * @param ordered array containing the fields names
  189.      * @param int type of query to build
  190.      *                           MDB2_AUTOQUERY_INSERT
  191.      *                           MDB2_AUTOQUERY_UPDATE
  192.      *                           MDB2_AUTOQUERY_DELETE
  193.      *                           MDB2_AUTOQUERY_SELECT
  194.      * @param string (in case of update and delete queries, this string will be put after the sql WHERE statement)
  195.      *
  196.      * @return string sql query for prepare()
  197.      * @access public
  198.      */
  199.     function buildManipSQL($table$table_fields$mode$where = false)
  200.     {
  201.         $db $this->getDBInstance();
  202.         if (MDB2::isError($db)) {
  203.             return $db;
  204.         }
  205.  
  206.         if ($db->options['quote_identifier']{
  207.             $table $db->quoteIdentifier($table);
  208.         }
  209.  
  210.         if (!empty($table_fields&& $db->options['quote_identifier']{
  211.             foreach ($table_fields as $key => $field{
  212.                 $table_fields[$key$db->quoteIdentifier($field);
  213.             }
  214.         }
  215.  
  216.         if ((false !== $where&& (null !== $where)) {
  217.             if (is_array($where)) {
  218.                 $where implode(' AND '$where);
  219.             }
  220.             $where ' WHERE '.$where;
  221.         }
  222.  
  223.         switch ($mode{
  224.         case MDB2_AUTOQUERY_INSERT:
  225.             if (empty($table_fields)) {
  226.                 return $db->raiseError(MDB2_ERROR_NEED_MORE_DATAnullnull,
  227.                 'Insert requires table fields'__FUNCTION__);
  228.             }
  229.             $cols implode(', '$table_fields);
  230.             $values '?'.str_repeat(', ?'(count($table_fields- 1));
  231.             return 'INSERT INTO '.$table.' ('.$cols.') VALUES ('.$values.')';
  232.             break;
  233.         case MDB2_AUTOQUERY_UPDATE:
  234.             if (empty($table_fields)) {
  235.                 return $db->raiseError(MDB2_ERROR_NEED_MORE_DATAnullnull,
  236.                 'Update requires table fields'__FUNCTION__);
  237.             }
  238.             $set implode(' = ?, '$table_fields).' = ?';
  239.             $sql 'UPDATE '.$table.' SET '.$set.$where;
  240.             return $sql;
  241.             break;
  242.         case MDB2_AUTOQUERY_DELETE:
  243.             $sql 'DELETE FROM '.$table.$where;
  244.             return $sql;
  245.             break;
  246.         case MDB2_AUTOQUERY_SELECT:
  247.             $cols !empty($table_fieldsimplode(', '$table_fields'*';
  248.             $sql 'SELECT '.$cols.' FROM '.$table.$where;
  249.             return $sql;
  250.             break;
  251.         }
  252.         return $db->raiseError(MDB2_ERROR_SYNTAXnullnull,
  253.                 'Non existant mode'__FUNCTION__);
  254.     }
  255.  
  256.     // }}}
  257.     // {{{ limitQuery()
  258.  
  259.     /**
  260.      * Generates a limited query
  261.      *
  262.      * @param string query
  263.      * @param array that contains the types of the columns in the result set
  264.      * @param integer the numbers of rows to fetch
  265.      * @param integer the row to start to fetching
  266.      * @param string which specifies which result class to use
  267.      * @param mixed   string which specifies which class to wrap results in
  268.      *
  269.      * @return MDB2_Result|MDB2_Errorresult set on success, a MDB2 error on failure
  270.      * @access public
  271.      */
  272.     function limitQuery($query$types$limit$offset = 0$result_class = true,
  273.         $result_wrap_class = false)
  274.     {
  275.         $db $this->getDBInstance();
  276.         if (MDB2::isError($db)) {
  277.             return $db;
  278.         }
  279.  
  280.         $result $db->setLimit($limit$offset);
  281.         if (MDB2::isError($result)) {
  282.             return $result;
  283.         }
  284.         return $db->query($query$types$result_class$result_wrap_class);
  285.     }
  286.  
  287.     // }}}
  288.     // {{{ execParam()
  289.  
  290.     /**
  291.      * Execute a parameterized DML statement.
  292.      *
  293.      * @param string the SQL query
  294.      * @param array if supplied, prepare/execute will be used
  295.      *        with this array as execute parameters
  296.      * @param array that contains the types of the values defined in $params
  297.      *
  298.      * @return int|MDB2_Erroraffected rows on success, a MDB2 error on failure
  299.      * @access public
  300.      */
  301.     function execParam($query$params = array()$param_types = null)
  302.     {
  303.         $db $this->getDBInstance();
  304.         if (MDB2::isError($db)) {
  305.             return $db;
  306.         }
  307.  
  308.         settype($params'array');
  309.         if (empty($params)) {
  310.             return $db->exec($query);
  311.         }
  312.  
  313.         $stmt $db->prepare($query$param_typesMDB2_PREPARE_MANIP);
  314.         if (MDB2::isError($stmt)) {
  315.             return $stmt;
  316.         }
  317.  
  318.         $result $stmt->execute($params);
  319.         if (MDB2::isError($result)) {
  320.             return $result;
  321.         }
  322.  
  323.         $stmt->free();
  324.         return $result;
  325.     }
  326.  
  327.     // }}}
  328.     // {{{ getOne()
  329.  
  330.     /**
  331.      * Fetch the first column of the first row of data returned from a query.
  332.      * Takes care of doing the query and freeing the results when finished.
  333.      *
  334.      * @param string the SQL query
  335.      * @param string that contains the type of the column in the result set
  336.      * @param array if supplied, prepare/execute will be used
  337.      *        with this array as execute parameters
  338.      * @param array that contains the types of the values defined in $params
  339.      * @param int|stringwhich column to return
  340.      *
  341.      * @return scalar|MDB2_Errordata on success, a MDB2 error on failure
  342.      * @access public
  343.      */
  344.     function getOne($query$type = null$params = array(),
  345.         $param_types = null$colnum = 0)
  346.     {
  347.         $db $this->getDBInstance();
  348.         if (MDB2::isError($db)) {
  349.             return $db;
  350.         }
  351.  
  352.         settype($params'array');
  353.         settype($type'array');
  354.         if (empty($params)) {
  355.             return $db->queryOne($query$type$colnum);
  356.         }
  357.  
  358.         $stmt $db->prepare($query$param_types$type);
  359.         if (MDB2::isError($stmt)) {
  360.             return $stmt;
  361.         }
  362.  
  363.         $result $stmt->execute($params);
  364.         if (!MDB2::isResultCommon($result)) {
  365.             return $result;
  366.         }
  367.  
  368.         $one $result->fetchOne($colnum);
  369.         $stmt->free();
  370.         $result->free();
  371.         return $one;
  372.     }
  373.  
  374.     // }}}
  375.     // {{{ getRow()
  376.  
  377.     /**
  378.      * Fetch the first row of data returned from a query.  Takes care
  379.      * of doing the query and freeing the results when finished.
  380.      *
  381.      * @param string the SQL query
  382.      * @param array that contains the types of the columns in the result set
  383.      * @param array if supplied, prepare/execute will be used
  384.      *        with this array as execute parameters
  385.      * @param array that contains the types of the values defined in $params
  386.      * @param int the fetch mode to use
  387.      *
  388.      * @return array|MDB2_Errordata on success, a MDB2 error on failure
  389.      * @access public
  390.      */
  391.     function getRow($query$types = null$params = array(),
  392.         $param_types = null$fetchmode = MDB2_FETCHMODE_DEFAULT)
  393.     {
  394.         $db $this->getDBInstance();
  395.         if (MDB2::isError($db)) {
  396.             return $db;
  397.         }
  398.  
  399.         settype($params'array');
  400.         if (empty($params)) {
  401.             return $db->queryRow($query$types$fetchmode);
  402.         }
  403.  
  404.         $stmt $db->prepare($query$param_types$types);
  405.         if (MDB2::isError($stmt)) {
  406.             return $stmt;
  407.         }
  408.  
  409.         $result $stmt->execute($params);
  410.         if (!MDB2::isResultCommon($result)) {
  411.             return $result;
  412.         }
  413.  
  414.         $row $result->fetchRow($fetchmode);
  415.         $stmt->free();
  416.         $result->free();
  417.         return $row;
  418.     }
  419.  
  420.     // }}}
  421.     // {{{ getCol()
  422.  
  423.     /**
  424.      * Fetch a single column from a result set and return it as an
  425.      * indexed array.
  426.      *
  427.      * @param string the SQL query
  428.      * @param string that contains the type of the column in the result set
  429.      * @param array if supplied, prepare/execute will be used
  430.      *        with this array as execute parameters
  431.      * @param array that contains the types of the values defined in $params
  432.      * @param int|stringwhich column to return
  433.      *
  434.      * @return array|MDB2_Errordata on success, a MDB2 error on failure
  435.      * @access public
  436.      */
  437.     function getCol($query$type = null$params = array(),
  438.         $param_types = null$colnum = 0)
  439.     {
  440.         $db $this->getDBInstance();
  441.         if (MDB2::isError($db)) {
  442.             return $db;
  443.         }
  444.  
  445.         settype($params'array');
  446.         settype($type'array');
  447.         if (empty($params)) {
  448.             return $db->queryCol($query$type$colnum);
  449.         }
  450.  
  451.         $stmt $db->prepare($query$param_types$type);
  452.         if (MDB2::isError($stmt)) {
  453.             return $stmt;
  454.         }
  455.  
  456.         $result $stmt->execute($params);
  457.         if (!MDB2::isResultCommon($result)) {
  458.             return $result;
  459.         }
  460.  
  461.         $col $result->fetchCol($colnum);
  462.         $stmt->free();
  463.         $result->free();
  464.         return $col;
  465.     }
  466.  
  467.     // }}}
  468.     // {{{ getAll()
  469.  
  470.     /**
  471.      * Fetch all the rows returned from a query.
  472.      *
  473.      * @param string the SQL query
  474.      * @param array that contains the types of the columns in the result set
  475.      * @param array if supplied, prepare/execute will be used
  476.      *        with this array as execute parameters
  477.      * @param array that contains the types of the values defined in $params
  478.      * @param int the fetch mode to use
  479.      * @param bool if set to true, the $all will have the first
  480.      *        column as its first dimension
  481.      * @param bool $force_array used only when the query returns exactly
  482.      *        two columns. If true, the values of the returned array will be
  483.      *        one-element arrays instead of scalars.
  484.      * @param bool $group if true, the values of the returned array is
  485.      *        wrapped in another array.  If the same key value (in the first
  486.      *        column) repeats itself, the values will be appended to this array
  487.      *        instead of overwriting the existing values.
  488.      *
  489.      * @return array|MDB2_Errordata on success, a MDB2 error on failure
  490.      * @access public
  491.      */
  492.     function getAll($query$types = null$params = array(),
  493.         $param_types = null$fetchmode = MDB2_FETCHMODE_DEFAULT,
  494.         $rekey = false$force_array = false$group = false)
  495.     {
  496.         $db $this->getDBInstance();
  497.         if (MDB2::isError($db)) {
  498.             return $db;
  499.         }
  500.  
  501.         settype($params'array');
  502.         if (empty($params)) {
  503.             return $db->queryAll($query$types$fetchmode$rekey$force_array$group);
  504.         }
  505.  
  506.         $stmt $db->prepare($query$param_types$types);
  507.         if (MDB2::isError($stmt)) {
  508.             return $stmt;
  509.         }
  510.  
  511.         $result $stmt->execute($params);
  512.         if (!MDB2::isResultCommon($result)) {
  513.             return $result;
  514.         }
  515.  
  516.         $all $result->fetchAll($fetchmode$rekey$force_array$group);
  517.         $stmt->free();
  518.         $result->free();
  519.         return $all;
  520.     }
  521.  
  522.     // }}}
  523.     // {{{ getAssoc()
  524.  
  525.     /**
  526.      * Fetch the entire result set of a query and return it as an
  527.      * associative array using the first column as the key.
  528.      *
  529.      * If the result set contains more than two columns, the value
  530.      * will be an array of the values from column 2-n.  If the result
  531.      * set contains only two columns, the returned value will be a
  532.      * scalar with the value of the second column (unless forced to an
  533.      * array with the $force_array parameter).  A MDB2 error code is
  534.      * returned on errors.  If the result set contains fewer than two
  535.      * columns, a MDB2_ERROR_TRUNCATED error is returned.
  536.      *
  537.      * For example, if the table 'mytable' contains:
  538.      * <pre>
  539.      *   ID      TEXT       DATE
  540.      * --------------------------------
  541.      *   1       'one'      944679408
  542.      *   2       'two'      944679408
  543.      *   3       'three'    944679408
  544.      * </pre>
  545.      * Then the call getAssoc('SELECT id,text FROM mytable') returns:
  546.      * <pre>
  547.      *    array(
  548.      *      '1' => 'one',
  549.      *      '2' => 'two',
  550.      *      '3' => 'three',
  551.      *    )
  552.      * </pre>
  553.      * ...while the call getAssoc('SELECT id,text,date FROM mytable') returns:
  554.      * <pre>
  555.      *    array(
  556.      *      '1' => array('one', '944679408'),
  557.      *      '2' => array('two', '944679408'),
  558.      *      '3' => array('three', '944679408')
  559.      *    )
  560.      * </pre>
  561.      *
  562.      * If the more than one row occurs with the same value in the
  563.      * first column, the last row overwrites all previous ones by
  564.      * default.  Use the $group parameter if you don't want to
  565.      * overwrite like this.  Example:
  566.      * <pre>
  567.      * getAssoc('SELECT category,id,name FROM mytable', null, null
  568.      *           MDB2_FETCHMODE_ASSOC, false, true) returns:
  569.      *    array(
  570.      *      '1' => array(array('id' => '4', 'name' => 'number four'),
  571.      *                   array('id' => '6', 'name' => 'number six')
  572.      *             ),
  573.      *      '9' => array(array('id' => '4', 'name' => 'number four'),
  574.      *                   array('id' => '6', 'name' => 'number six')
  575.      *             )
  576.      *    )
  577.      * </pre>
  578.      *
  579.      * Keep in mind that database functions in PHP usually return string
  580.      * values for results regardless of the database's internal type.
  581.      *
  582.      * @param string the SQL query
  583.      * @param array that contains the types of the columns in the result set
  584.      * @param array if supplied, prepare/execute will be used
  585.      *        with this array as execute parameters
  586.      * @param array that contains the types of the values defined in $params
  587.      * @param bool $force_array used only when the query returns
  588.      *  exactly two columns.  If TRUE, the values of the returned array
  589.      *  will be one-element arrays instead of scalars.
  590.      * @param bool $group if TRUE, the values of the returned array
  591.      *        is wrapped in another array.  If the same key value (in the first
  592.      *        column) repeats itself, the values will be appended to this array
  593.      *        instead of overwriting the existing values.
  594.      *
  595.      * @return array|MDB2_Errordata on success, a MDB2 error on failure
  596.      * @access public
  597.      */
  598.     function getAssoc($query$types = null$params = array()$param_types = null,
  599.         $fetchmode = MDB2_FETCHMODE_DEFAULT$force_array = false$group = false)
  600.     {
  601.         $db $this->getDBInstance();
  602.         if (MDB2::isError($db)) {
  603.             return $db;
  604.         }
  605.  
  606.         settype($params'array');
  607.         if (empty($params)) {
  608.             return $db->queryAll($query$types$fetchmodetrue$force_array$group);
  609.         }
  610.  
  611.         $stmt $db->prepare($query$param_types$types);
  612.         if (MDB2::isError($stmt)) {
  613.             return $stmt;
  614.         }
  615.  
  616.         $result $stmt->execute($params);
  617.         if (!MDB2::isResultCommon($result)) {
  618.             return $result;
  619.         }
  620.  
  621.         $all $result->fetchAll($fetchmodetrue$force_array$group);
  622.         $stmt->free();
  623.         $result->free();
  624.         return $all;
  625.     }
  626.  
  627.     // }}}
  628.     // {{{ executeMultiple()
  629.  
  630.     /**
  631.      * This function does several execute() calls on the same statement handle.
  632.      * $params must be an array indexed numerically from 0, one execute call is
  633.      * done for every 'row' in the array.
  634.      *
  635.      * If an error occurs during execute(), executeMultiple() does not execute
  636.      * the unfinished rows, but rather returns that error.
  637.      *
  638.      * @param resource query handle from prepare()
  639.      * @param array numeric array containing the data to insert into the query
  640.      *
  641.      * @return bool|MDB2_Errortrue on success, a MDB2 error on failure
  642.      * @access public
  643.      * @see prepare(), execute()
  644.      */
  645.     function executeMultiple($stmt$params = null)
  646.     {
  647.         if (MDB2::isError($stmt)) {
  648.             return $stmt;
  649.         }
  650.         for ($i = 0$j count($params)$i $j$i++{
  651.             $result $stmt->execute($params[$i]);
  652.             if (MDB2::isError($result)) {
  653.                 return $result;
  654.             }
  655.         }
  656.         return MDB2_OK;
  657.     }
  658.  
  659.     // }}}
  660.     // {{{ getBeforeID()
  661.  
  662.     /**
  663.      * Returns the next free id of a sequence if the RDBMS
  664.      * does not support auto increment
  665.      *
  666.      * @param string name of the table into which a new row was inserted
  667.      * @param string name of the field into which a new row was inserted
  668.      * @param bool when true the sequence is automatic created, if it not exists
  669.      * @param bool if the returned value should be quoted
  670.      *
  671.      * @return int|MDB2_Errorid on success, a MDB2 error on failure
  672.      * @access public
  673.      */
  674.     function getBeforeID($table$field = null$ondemand = true$quote = true)
  675.     {
  676.         $db $this->getDBInstance();
  677.         if (MDB2::isError($db)) {
  678.             return $db;
  679.         }
  680.  
  681.         if ($db->supports('auto_increment'!== true{
  682.             $seq $table.(empty($field'' '_'.$field);
  683.             $id $db->nextID($seq$ondemand);
  684.             if (!$quote || MDB2::isError($id)) {
  685.                 return $id;
  686.             }
  687.             return $db->quote($id'integer');
  688.         elseif (!$quote{
  689.             return null;
  690.         }
  691.         return 'NULL';
  692.     }
  693.  
  694.     // }}}
  695.     // {{{ getAfterID()
  696.  
  697.     /**
  698.      * Returns the autoincrement ID if supported or $id
  699.      *
  700.      * @param mixed value as returned by getBeforeId()
  701.      * @param string name of the table into which a new row was inserted
  702.      * @param string name of the field into which a new row was inserted
  703.      *
  704.      * @return int|MDB2_Errorid on success, a MDB2 error on failure
  705.      * @access public
  706.      */
  707.     function getAfterID($id$table$field = null)
  708.     {
  709.         $db $this->getDBInstance();
  710.         if (MDB2::isError($db)) {
  711.             return $db;
  712.         }
  713.  
  714.         if ($db->supports('auto_increment'!== true{
  715.             return $id;
  716.         }
  717.         return $db->lastInsertID($table$field);
  718.     }
  719.  
  720.     // }}}
  721. }
  722. ?>

Documentation generated on Mon, 29 Oct 2012 16:00:09 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.