| New file |
|---|
| 0,0 → 1,250 |
|---|
| <?php |
| // |
| // Pear DB Pager - Retrieve and return information of databases |
| // result sets |
| // |
| // Copyright (C) 2001 Tomas Von Veschler Cox <cox@idecnet.com> |
| // |
| // This library is free software; you can redistribute it and/or |
| // modify it under the terms of the GNU Lesser General Public |
| // License as published by the Free Software Foundation; either |
| // version 2.1 of the License, or (at your option) any later version. |
| // |
| // This library is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| // Lesser General Public License for more details. |
| // |
| // You should have received a copy of the GNU Lesser General Public |
| // License along with this library; if not, write to the Free Software |
| // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| // |
| // |
| // $Id: Pager.php,v 1.3 2002/05/12 13:59:40 cox Exp $ |
| |
| require_once 'PEAR.php'; |
| require_once 'DB.php'; |
| |
| /** |
| * This class handles all the stuff needed for displaying paginated results |
| * from a database query of Pear DB, in a very easy way. |
| * Documentation and examples of use, can be found in: |
| * http://vulcanonet.com/soft/pager/ (could be outdated) |
| * |
| * IMPORTANT! |
| * Since PEAR DB already support native row limit (more fast and avaible in |
| * all the drivers), there is no more need to use $pager->build() or |
| * the $pager->fetch*() methods. |
| * |
| * Usage example: |
| * |
| *< ?php |
| * require_once 'DB/Pager.php'; |
| * $db = DB::connect('your DSN string'); |
| * $from = 0; // The row to start to fetch from (you might want to get this |
| * // param from the $_GET array |
| * $limit = 10; // The number of results per page |
| * $maxpages = 10; // The number of pages for displaying in the pager (optional) |
| * $res = $db->limitQuery($sql, $from, $limit); |
| * $nrows = 0; // Alternative you could use $res->numRows() |
| * while ($row = $res->fetchrow()) { |
| * // XXX code for building the page here |
| * $nrows++; |
| * } |
| * $data = DB_Pager::getData($from, $limit, $nrows, $maxpages); |
| * // XXX code for building the pager here |
| * ? > |
| * |
| * @version 0.7 |
| * @author Tomas V.V.Cox <cox@idecnet.com> |
| * @see http://vulcanonet.com/soft/pager/ |
| */ |
| |
| class DB_Pager extends PEAR |
| { |
| |
| /** |
| * Constructor |
| * |
| * @param object $res A DB_result object from Pear_DB |
| * @param int $from The row to start fetching |
| * @param int $limit How many results per page |
| * @param int $numrows Pager will automatically |
| * find this param if is not given. If your Pear_DB backend extension |
| * doesn't support numrows(), you can manually calculate it |
| * and supply later to the constructor |
| * @deprecated |
| */ |
| function DB_Pager (&$res, $from, $limit, $numrows = null) |
| { |
| $this->res = $res; |
| $this->from = $from; |
| $this->limit = $limit; |
| $this->numrows = $numrows; |
| } |
| |
| /** |
| * Calculates all the data needed by Pager to work |
| * |
| * @return mixed An assoc array with all the data (see getData) |
| * or DB_Error on error |
| * @see DB_Pager::getData |
| * @deprecated |
| */ |
| function build() |
| { |
| // if there is no numrows given, calculate it |
| if ($this->numrows === null) { |
| $this->numrows = $this->res->numrows(); |
| if (DB::isError($this->numrows)) { |
| return $this->numrows; |
| } |
| } |
| $data = $this->getData($this->from, $this->limit, $this->numrows); |
| if (DB::isError($data)) { |
| return $data; |
| } |
| $this->current = $this->from - 1; |
| $this->top = $data['to']; |
| return $data; |
| } |
| |
| /** |
| * @deprecated |
| */ |
| function fetchRow($mode=DB_FETCHMODE_DEFAULT) |
| { |
| $this->current++; |
| if ($this->current >= $this->top) { |
| return null; |
| } |
| return $this->res->fetchRow($mode, $this->current); |
| } |
| |
| /** |
| * @deprecated |
| */ |
| function fetchInto(&$arr, $mode=DB_FETCHMODE_DEFAULT) |
| { |
| $this->current++; |
| if ($this->current >= $this->top) { |
| return null; |
| } |
| return $this->res->fetchInto($arr, $mode, $this->current); |
| } |
| |
| /* |
| * Gets all the data needed to paginate results |
| * This is an associative array with the following |
| * values filled in: |
| * |
| * array( |
| * 'current' => X, // current page you are |
| * 'numrows' => X, // total number of results |
| * 'next' => X, // row number where next page starts |
| * 'prev' => X, // row number where prev page starts |
| * 'remain' => X, // number of results remaning *in next page* |
| * 'numpages'=> X, // total number of pages |
| * 'from' => X, // the row to start fetching |
| * 'to' => X, // the row to stop fetching |
| * 'limit' => X, // how many results per page |
| * 'maxpages' => X, // how many pages to show (google style) |
| * 'firstpage' => X, // the row number of the first page |
| * 'lastpage' => X, // the row number where the last page starts |
| * 'pages' => array( // assoc with page "number => start row" |
| * 1 => X, |
| * 2 => X, |
| * 3 => X |
| * ) |
| * ); |
| * @param int $from The row to start fetching |
| * @param int $limit How many results per page |
| * @param int $numrows Number of results from query |
| * |
| * @return array associative array with data or DB_error on error |
| * |
| */ |
| function &getData($from, $limit, $numrows, $maxpages = false) |
| { |
| if (empty($numrows) || ($numrows < 0)) { |
| return null; |
| } |
| $from = (empty($from)) ? 0 : $from; |
| |
| if ($limit <= 0) { |
| return PEAR::raiseError (null, 'wrong "limit" param', null, |
| null, null, 'DB_Error', true); |
| } |
| |
| // Total number of pages |
| $pages = ceil($numrows/$limit); |
| $data['numpages'] = $pages; |
| |
| // first & last page |
| $data['firstpage'] = 1; |
| $data['lastpage'] = $pages; |
| |
| // Build pages array |
| $data['pages'] = array(); |
| for ($i=1; $i <= $pages; $i++) { |
| $offset = $limit * ($i-1); |
| $data['pages'][$i] = $offset; |
| // $from must point to one page |
| if ($from == $offset) { |
| // The current page we are |
| $data['current'] = $i; |
| } |
| } |
| if (!isset($data['current'])) { |
| return PEAR::raiseError (null, 'wrong "from" param', null, |
| null, null, 'DB_Error', true); |
| } |
| |
| // Limit number of pages (goole algoritm) |
| if ($maxpages) { |
| $radio = floor($maxpages/2); |
| $minpage = $data['current'] - $radio; |
| if ($minpage < 1) { |
| $minpage = 1; |
| } |
| $maxpage = $data['current'] + $radio - 1; |
| if ($maxpage > $data['numpages']) { |
| $maxpage = $data['numpages']; |
| } |
| foreach (range($minpage, $maxpage) as $page) { |
| $tmp[$page] = $data['pages'][$page]; |
| } |
| $data['pages'] = $tmp; |
| $data['maxpages'] = $maxpages; |
| } else { |
| $data['maxpages'] = null; |
| } |
| |
| // Prev link |
| $prev = $from - $limit; |
| $data['prev'] = ($prev >= 0) ? $prev : null; |
| |
| // Next link |
| $next = $from + $limit; |
| $data['next'] = ($next < $numrows) ? $next : null; |
| |
| // Results remaining in next page & Last row to fetch |
| if ($data['current'] == $pages) { |
| $data['remain'] = 0; |
| $data['to'] = $numrows; |
| } else { |
| if ($data['current'] == ($pages - 1)) { |
| $data['remain'] = $numrows - ($limit*($pages-1)); |
| } else { |
| $data['remain'] = $limit; |
| } |
| $data['to'] = $data['current'] * $limit; |
| } |
| $data['numrows'] = $numrows; |
| $data['from'] = $from + 1; |
| $data['limit'] = $limit; |
| |
| return $data; |
| } |
| } |
| ?> |