Home | Classes | Modules | Annotated | Hierarchy | Functions | Files

DataSet.php

Go to the documentation of this file.

<?php
/*
 *  $Id: DataSet.php,v 1.5 2004/05/22 09:59:57 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';

abstract class DataSet implements IteratorAggregate {

    const ALL_RECORDS = 0;

    protected $records;

    protected $conn;

    protected $allRecordsRetrieved = false;

    protected $recordRetrievedCount = 0;

    protected $lastFetchSize = 0;

    protected $totalFetchCount = 0;

    protected $columns;

    protected $selectSql;

    protected $keyDef;

    protected $resultSet;

    protected $stmt;    

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

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

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

    public function removeRecord(Record $rec)
    {
        $loc = array_search($rec, $this->records, true);
        $removeRec = array_splice($this->records, $loc, 1);                 
        return $removeRec;
    }

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

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

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

        if ($this->resultSet !== null && !is_a($this,'QueryDataSet')) {
            $this->resultSet->close();
        }
            
        $this->resultSet = null;
        
        if ( $this->stmt !== null ) {
            $this->stmt->close();
        }

        $this->conn = null;
    }

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

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

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

    public function getRecord($pos)
    {
        if ($this->containsRecord($pos)) {
            $rec = $this->records[$pos];
            if (is_a($this, 'TableDataSet')) {
                $rec->markForUpdate();
            }
            $this->recordRetrievedCount++;
            return $rec;
        }
        throw new DataSetException ("Record not found at index: " . $pos);
    }

    public function findRecord($pos) 
    {
        if ($this->containsRecord($pos)) {
            return $this->records[$pos];
        }
        throw new DataSetException ("Record not found at index: " . $pos);
    }

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

    public 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) {
            throw new DataSetException("You must call DataSet::clearRecords() before executing DataSet::fetchRecords() again!");
        }

        try {
        
            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;
                $this->resultSet = $this->stmt->executeQuery($this->selectSql);
            }

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

                $this->records = array();

                $startCounter = 0;
                $fetchCount = 0;
                while (! $this->allRecordsRetrieved() ) {
                    if ($this->resultSet->next()) {
                        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 {
                        $this->setAllRecordsRetrieved(true);
                        break;
                    }
                }                
                $this->lastFetchSize = $fetchCount;
            }
        } catch (SQLException $e) {
            if ($this->stmt) $this->stmt->close();
            throw $e;
        }

        return $this;
    }

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

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

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

    public abstract function getSelectSql();

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

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


class DataSetIterator implements Iterator {

    private $ds;
    private $size;
    private $pos;
    
    function __construct(DataSet $ds) {
        $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[php5] library.