Source for file dblist.php

Documentation is available at dblist.php

  1. <?php
  2. /**
  3. * generic database list/export class
  4. *
  5. * @author    Stuart Prescott
  6. * @copyright  Copyright Stuart Prescott
  7. * @license    http://opensource.org/licenses/gpl-license.php GNU Public License
  8. * @version    $Id$
  9. * @package    Bumblebee
  10. * @subpackage FormsLibrary
  11. */
  12.  
  13. /** Load ancillary functions */
  14. require_once 'inc/typeinfo.php';
  15. checkValidInclude();
  16.  
  17. /** uses an OutputFormatter to format the data */
  18. require_once 'inc/formslib/outputformatter.php';
  19. /** export formatting codes */
  20. require_once 'inc/exportcodes.php';
  21.  
  22. /**
  23. * generic database list/export class
  24. *
  25. * @package    Bumblebee
  26. * @subpackage FormsLibrary
  27. * @todo //TODO: codedoc
  28. */
  29. class DBList {
  30.   var $restriction;
  31.   var $unionrestriction = array();
  32.   var $join = array();
  33.   var $order;
  34.   var $group;
  35.   var $union;
  36.   var $returnFields;
  37.   var $numReturnFields;
  38.   var $omitFields = array();
  39.   var $fieldOrder;
  40.   var $formatter;
  41.   var $distinct = 0;
  42.   var $table;
  43.   var $data;
  44.   var $formatdata;
  45.   var $outputFormat = EXPORT_FORMAT_CUSTOM;
  46.   var $breakfield;
  47.   var $fatal_sql = 1;
  48.  
  49.   /**
  50.   *  Create a new DBList object
  51.   *
  52.   * @param string $table   name of (primary) table to be interrogated
  53.   * @param mixed  $returnFields   single column name or list of column names to be returned from the db
  54.   * @param mixed  $restriction    single or list of restrictions to be 'AND'ed together
  55.   * @param boolean $distinct      select only DISTINCT rows from the db
  56.   */
  57.   function DBList($table, $returnFields, $restriction, $distinct=false) {
  58.     $this->table = $table;
  59.     $this->distinct = $distinct;
  60.     if (is_array($restriction)) {
  61.       $this->restriction = $restriction;
  62.     } else {
  63.       $this->restriction = array($restriction);
  64.     }
  65.     if (is_array($returnFields)) {
  66.       $this->returnFields = $returnFields;
  67.     } else {
  68.       $this->returnFields = array($returnFields);
  69.     }
  70.     // calculate some values in advance and cache them to speed this class with large datasets
  71.     $this->numReturnFields = count($this->returnFields);
  72.     $this->returnFieldAliases = array();
  73.     $this->returnFieldCells = array();
  74.     for ($i=0; $i<$this->numReturnFields; $i++) {
  75.       $this->returnFieldAliases[$this->returnFields[$i]->alias] = $i;
  76.       $cell = array();
  77.       $cell['format'] = $this->returnFields[$i]->format;
  78.       $cell['width'] =  isset($this->returnFields[$i]->width) ? $this->returnFields[$i]->width : 10;
  79.       $this->returnFieldCells[$this->returnFields[$i]->alias] = $cell;
  80.     }
  81.   }
  82.  
  83.   /**
  84.   * Fill the object from the database
  85.   */
  86.   function fill() {
  87.     // construct the query
  88.     if (is_array($this->union) && count($this->union)) {
  89.       $union = array();
  90.       foreach ($this->union as $u) {
  91.         $u->restriction = array_merge($u->restriction, $this->unionrestriction);
  92.         $union[] = $u->_getSQLsyntax();
  93.       }
  94.       $q = '('.join($union, ') UNION ALL (').')';
  95.       $q .= (is_array($this->order) ? ' ORDER BY '.join($this->order,', ') : '');
  96.       $q .= (is_array($this->group) ? ' GROUP BY '.join($this->group,', ') : '');
  97.     } else {
  98.       $q = $this->_getSQLsyntax();
  99.     }
  100.     $sql = db_get($q, $this->fatal_sql);
  101.     $data = array();
  102.     while ($g = db_fetch_array($sql)) {
  103.       $data[] = $g;
  104.     }
  105.     if (isset($this->manualGroup) && $this->manualGroup != '') {
  106.       $sumdata = array();
  107.       $row=0;
  108.       $numrows = count($data);
  109.       while ($row < $numrows) {
  110.         $current = $data[$row][$this->manualGroup];
  111.         $currentRow = $data[$row];
  112.         $sums = array();
  113.         foreach ($this->manualSum as $col) {
  114.           $sums[$col] = 0;
  115.         }
  116.         while ($row < $numrows && $data[$row][$this->manualGroup] == $current) {
  117.           foreach ($this->manualSum as $col) {
  118.             $sums[$col] += $data[$row][$col];
  119.           }
  120.           $row++;
  121.         }
  122.         foreach ($this->manualSum as $col) {
  123.           $currentRow[$col] = $sums[$col];
  124.         }
  125.         $sumdata[] = $currentRow;
  126.       }
  127.       $this->data = $sumdata;
  128.     } else {
  129.       $this->data = $data;
  130.     }
  131.   }
  132.  
  133.   /**
  134.   * generate the appropriate SQL syntax for this query
  135.   *
  136.   * @return string SQL query for this object
  137.   */
  138.   function _getSQLsyntax() {
  139.     global $TABLEPREFIX;
  140.     $fields = array();
  141.     foreach ($this->returnFields as $v) {
  142.       $fields[] = $v->name .(isset($v->alias) ? ' AS '.$v->alias : '');
  143.     }
  144.     $q = 'SELECT '.($this->distinct ? 'DISTINCT ' : ' ')
  145.           .join($fields, ', ')
  146.         .' FROM '.$TABLEPREFIX.$this->table.' AS '.$this->table.' ';
  147.     foreach ($this->join as $t) {
  148.       $q .= ' LEFT JOIN '.$TABLEPREFIX.$t['table'].' AS '.(isset($t['alias']) ? $t['alias'] : $t['table'])
  149.            .' ON '.$t['condition'];
  150.     }
  151.     $q .= ' WHERE '. join($this->restriction, ' AND ');
  152.     $q .= (is_array($this->order) ? ' ORDER BY '.join($this->order,', ') : '');
  153.     $q .= (is_array($this->group) ? ' GROUP BY '.join($this->group,', ') : '');
  154.     return $q;
  155.   }
  156.  
  157.   /**
  158.   * format the list using the designated formats into another list
  159.   */
  160.   function formatList() {
  161.     //preDump($this->omitFields);
  162.     $this->formatdata = array();
  163.     if (! is_array($this->fieldOrder)) {
  164.       $this->fieldOrder = array();
  165.       foreach ($this->returnFields as $f) {
  166.         $this->fieldOrder[] = $f->alias;
  167.       }
  168.     }
  169.     $numdata = count($this->data);
  170.     for ($i=0; $i<$numdata; $i++) {
  171.       $this->formatdata[$i] = $this->format($this->data[$i]);
  172.     }
  173.   }
  174.  
  175.   /**
  176.   * format a row of data
  177.   * @param array $data   name=>value pairs of data
  178.   * @return string   formatter line of data
  179.   */
  180.   function format($data/*, $isHeader=false*/) {
  181.     $d = array();
  182.     foreach ($this->fieldOrder as $f) {
  183.       // performance of array_key_exists() can be a problem
  184.       // see  http://bugs.php.net/37563
  185.       //if (! array_key_exists($f, $this->omitFields)) {
  186.       if (! isset($this->omitFields[$f])) {
  187.         $d[$f] = $data[$f];
  188.       }
  189.     }
  190.     if (EXPORT_FORMAT_CSV & $this->outputFormat)
  191.       return join(preg_replace(array('/"/',     '/^(.*,.*)$/'),
  192.                                array('\\"',   '"$1"'       ), $d), ',');
  193.     if (EXPORT_FORMAT_TAB & $this->outputFormat)
  194.         return join(preg_replace("/^(.*\t.*)$/", '"$1"', $d), "\t");
  195.     if (EXPORT_FORMAT_USEARRAY & $this->outputFormat)
  196.         return $this->_makeArray($d/*, $isHeader*/);
  197.  
  198.     return $this->formatter->format($d);
  199.   }
  200.  
  201.   /**
  202.   * format a header row
  203.   * @return string   formatter header row
  204.   */
  205.   function outputHeader() {
  206.     $d = array();
  207.     foreach ($this->returnFields as $f) {
  208.       $d[$f->alias] = $f->heading;
  209.     }
  210.     return $this->format($d/*, true*/);
  211.   }
  212.  
  213.   /**
  214.   * create a row of data with the value and some formatting data for use by the Array/HTML/PDF Export
  215.   * @return array   list of array(value=>$value, format=>$format, width=>$width)
  216.   */
  217.   function _makeArray(&$d/*, $isHeader=false*/) {
  218.     $row = array();
  219.     foreach ($d as $alias => $val) {
  220.       $cell = $this->returnFieldCells[$alias];
  221.       // use the cached reverse mapping of field aliases/names back to the field number
  222.       //$f = $this->returnFields[$this->returnFieldAliases[$alias]];
  223. //       $cell = array();
  224.       //$cell['value'] = $this->formatVal($val, $f->format, $isHeader);
  225.       $cell['value'] = $val;
  226. //       $cell['format'] = $f->format;
  227. //       $cell['width'] =  isset($f->width) ? $f->width : 10;
  228.       $row[] = $cell;
  229.     }
  230.     return $row;
  231.   }
  232.  
  233.  /**
  234.   * Create a set of OutputFormatter objects to handle the display of this object.
  235.   *
  236.   * @param string $f1    sprintf format (see PHP manual)
  237.   * @param array $v1     array of indices that will be used to fill the fields in the sprintf format from a $data array passed to the formatter later.
  238.   */
  239.   function setFormat($f, $v) {
  240.     $this->formatter = new OutputFormatter($f, $v);
  241.   }
  242.  
  243. } // class DBList
  244.  
  245.  
  246. ?>

Documentation generated on Tue, 06 Mar 2007 10:01:19 +0000 by phpDocumentor 1.3.0