Home | Classes | Modules | Annotated | Functions | Files

DataSet.php

Go to the documentation of this file.

<?php
/*
 *  $Id: DataSet.php,v 1.2 2004/05/22 13:38:13 micha Exp $
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information please see
 * <http://creole.phpdb.org>.
 * 
 * This product includes software based on the Village framework,  
 * http://share.whichever.com/index.php?SCREEN=village.
 */

require_once 'jargon/Record.php';
include_once 'jargon/DataSetException.php';

class DataSet /*implements IteratorAggregate*/ 
{
  function ALL_RECORDS() { return 0; }

  var $records;

  var $conn;

  var $allRecordsRetrieved = false;

  var $recordRetrievedCount = 0;

  var $lastFetchSize = 0;

  var $totalFetchCount = 0;

  var $columns;

  var $selectSql;

  var $keyDef;

  var $resultSet;

  var $stmt;    

  function & getIterator()
  {
    $it =& new DataSetIterator($this);
    return $it;
  }
  
  function &resultSet()
  {
    if ($this->resultSet === null) {
      return new DataSetException (0, "ResultSet is null.");
    }            
    return $this->resultSet;
  }

  function allRecordsRetrieved()
  {
    return $this->allRecordsRetrieved;
  }

  function setAllRecordsRetrieved($set)
  {
    $this->allRecordsRetrieved = $set;
  }

  function &removeRecord(/*Record*/ &$rec)
  {
    Creole::typeHint($rec, 'Record', 'DataSet', 'removeRecord');
    $loc = array_search($rec, $this->records, true);

    if ($loc === false) {
      return false;
    }

    return array_splice($this->records, $loc, 1);                 
  }

  function &clearRecords()
  {
    $this->records = null;
    return $this;
  }

  function &releaseRecords()
  {
    $this->records = null;
    $this->recordRetrievedCount = 0;
    $this->lastFetchSize = 0;
    $this->setAllRecordsRetrieved(false);
    return $this;
  }

  function close()
  {
    $this->releaseRecords();
    $this->schema = null;

    if ($this->resultSet !== null && !is_a($this,'QueryDataSet')) {
      /* no check for return value as it returns void */
      $this->resultSet->close();
    }
        
    $this->resultSet = null;
    
    if ( $this->stmt !== null ) {
      $this->stmt->close();
    }

    $this->conn = null;
  }

  function &reset()
  {
    if (! ($this->resultSet !== null && is_a($this, 'QueryDataSet'))) {
      return $this->releaseRecords();
    } else {
      return new DataSetException(0, "You cannot call reset() on a QueryDataSet.");
    }
  }

  function &connection()
  {
    return $this->conn;
  }

  function &schema()
  {
    return $this->schema;
  }

  function & getRecord($pos)
  {
    if ($this->containsRecord($pos)) {
      $rec =& $this->records[$pos];
      if (is_a($this, 'TableDataSet')) {
        /* only throws an exception if not TableDataSet */
        $rec->markForUpdate();
      }
      $this->recordRetrievedCount++;
      return $rec;
    }

    return false;
  }

  function & findRecord($pos) 
  {
    if (! $this->containsRecord($pos)) {
      return false;
    }

    return $this->records[$pos];
  }

  function containsRecord($pos)
  {
    return (isset($this->records[$pos]));            
  }   

  function fetchRecords($p1 = 0, $p2 = null)
  {
    if ($p2 !== null) {
      $start = $p1;
      $max = $p2;
    } else {
      $start = 0;
      $max = $p1;
    }
    
    if ($this->lastFetchSize() > 0 && $this->records !== null) {
      return new DataSetException("You must call DataSet::clearRecords() before executing DataSet::fetchRecords() again!");
    }

    if ($this->stmt === null && $this->resultSet === null) {
      $this->stmt =& $this->conn->createStatement();
      $this->stmt->setOffset($start);
      $this->stmt->setLimit($max);
      // reset, since native limit applied
      $start = 0;
      $max = 0;
      $rs =& $this->stmt->executeQuery($this->selectSql);

      if (Creole::isError($rs)) {
        return $rs;
      }

      $this->resultSet =& $rs;
    }

    if ($this->resultSet !== null) 
    {
      $this->records = array();

      $startCounter = 0;
      $fetchCount = 0;

      while (! $this->allRecordsRetrieved() ) 
      {
        $e = null;

        if (($e = $this->resultSet->next()) === true) 
        {
          if ($startCounter >= $start) {
            $this->records[] =& new Record($this);
            $fetchCount++;
            if ($fetchCount === $max) { // check after because we must fetch at least 1
              break;
            }
          } else {
            $startCounter++;
          }
        }
        else if (Creole::isError($e)) {
          $this->stmt->close();
          return $e;
        } 
        else {
          $this->setAllRecordsRetrieved(true);
          break;
        }
      }                
      $this->lastFetchSize = $fetchCount;
    }

    return $this;
  }

  function lastFetchSize()
  {
    return $this->lastFetchSize;
  }

  function & keydef()
  {
    return $this->keyDef;
  }

  function __toString()
  {
    $sb = "";        
    for ($i = 0, $size = $this->size(); $i < $size; $i++) {
      $sb .= $this->getRecord($i);
    }
    return $sb;
  }       

  function getSelectSql()
  {
    trigger_error (
      "DataSet::getSelectSql(): abstract function has to be reimplemented !",
      E_USER_ERROR
    );
  }

  function & getColumns()
  {
    return $this->columns;
  }

  function size()
  {
    if ( $this->records === null ) {
      return 0;
    }
    return count($this->records);
  }
}


class DataSetIterator /*implements Iterator*/ 
{
  var $ds;
  var $size;
  var $pos;
  
  function DataSetIterator(/*DataSet*/ &$ds) 
  {
    if (! is_a($rec, 'DataSet')) {
      trigger_error (
        "DataSetIterator::DataSetIterator(): parameter 1 not of type 'DataSet' !",
        E_USER_ERROR
      );
    }

    $this->ds =& $ds;
    $this->size = $ds->size();
  }
  
  function rewind() 
  {
    $this->pos = 0;
  }
  
  function valid() 
  {
    return $this->pos < $this->size;
  }
  
  function key() 
  {
    return $this->pos;
  }
  
  function & current() 
  {
    return $this->ds->getRecord($this->pos);
  }
  
  function next() 
  {
    $this->pos++;
  }
}

---

This file is part of the Creole[php4] library.