SWAT/model2/SDatabaseModel.php5

<?php

abstract class SDatabaseModel extends SModel2 {
    /* The database interface for this object */
    private $DBI = null;
    /* The name of the database entity/table storing this object */
    private $tableName;
    /* The name of the primary key attribute in this entity */
    private $primaryKey;
    /* If true, the primary key is an auto-increment field and should not be set manually */
    private $primaryKeyIsAuto;
    /* Foreign key linkage information (basically, list of tables and attributes) */
    private $linkage;
    /* Used to pass list of attributes to have their 'commit' field reset after an INSERT or UPDATE */
    private $_reset;
    /* Set to true if we are in a transaction...so that commits are idempotent */
    private $_inTransaction = false;

    /* Used when filling in objects for getListMulti() */
    private static $_cache = array();

    /* ----------------------------------------------- */
    /* ORM FIND/LOAD/SAVE FUNCTIONS
    /* ----------------------------------------------- */

    public function populate($constraints, $multi = false) {
        // get an array with one item, meeting the constraints
        if($multi)
            list($result, $mapping) = self::getListBaseMulti($this->DBI,
                                        $constraints,
                                        array(1),
                                        array(),
                                        false,
                                        get_class($this),
                                        false);
        else
            $result = self::getListBase($this->DBI,
                                        $constraints,
                                        array(1),           // may want to change this if people need a warning
                                        array(),
                                        false,
                                        get_class($this),
                                        false);

        if(!$result) {
            $this->setError('Error attempting to populate');
            return false;
        }

        // return false if no matches found
        if($result->numRows() == 0) {
            $this->setError('No object found for constraints ' . print_r($constraints, true));
            return false;
        }

        // copy values from item
        if($multi) {
            if(!$this->setAttrsFromMultiDBResult($result->nextRow(), $mapping))
                return false;
        }
        else {
            if(!$this->setAttrsFromDBResult($result->nextRow()))
                return false;
        }

        $this->updateBase();

        return true;
    }

    protected function populateWith(&$row, $mapping = null, $as = null) {
        $toDo = array();
        foreach($row as $fullAttr => $value) {
            $dotPos = strrpos($fullAttr, '.');
            $attr = substr($fullAttr, $dotPos + 1);
            $prefix = substr($fullAttr, 0, $dotPos);
            if($as !== null && $prefix != $as)
                continue;
            if($mapping != null) {
                if(!isset($mapping[$prefix][0]))
                    continue;
                $table = $mapping[$prefix][0];
            }
            else
                $table = $prefix;   // hopefully!
            if($table != $this->tableName)
                continue;
            unset($row[$fullAttr]);
            $this->set($attr, $value);
            $foreign = $this->getAttributeForeign($attr);
            if(count($foreign) > 0 && isset($mapping["$prefix.$foreign[object]"]) && $value != null) {
                $cls = $this->getAttributeType($foreign['object']);
                if(self::$_cache === null || !isset(self::$_cache[$cls][$value])) {
                    $obj = new $cls();
                    $toDo[] = array($foreign['object'], $obj, "$prefix.$foreign[object]", $value);
                }
                else
                    $this->set($foreign['object'], self::$_cache[$cls][$value]);
            }
        }

        foreach($toDo as $td) {
            $td[1]->populateWith($row, $mapping, $td[2]);
            if(self::$_cache !== null)
                self::$_cache[get_class($td[1])][$td[3]] = $td[1];
            $this->set($td[0], $td[1]);
        }

        $this->updateBase();

        return true;
    }

    protected function setAttrsFromDBResult($dbResult) {
        // look at each of our attributes
        foreach($this->getAttributes(true) as $attrName => $attrProps) {
            if($attrProps['commit'] == self::COMMIT_FIRST)
                $this->changeAttribute($attrName, 'commit', self::COMMIT_CHANGED);
            // if there is a result in the database from that attribute
            $dbAttrName = 'Base.' . $attrName;
            if(isset($dbResult[$dbAttrName])) {
                // Decide on how to copy each attribute's DB value to the object,
                // based on the attribute's type
                switch($attrProps['type']) {
                    case 'int':
                    case 'string':
                    case 'float':
                    case 'time':
                        // Set the object value directly from the DB value
                        $this->set($attrName, $dbResult[$dbAttrName]);
                        break;
                    default:
                        // Create a new instance of the class specified by the attribute type
                        $cls = $this->attrProps['type'];
                        $obj = new $cls();
                        if ($obj == null) {
                            $this->setError("Could not instantiate class '$cls'"
                                    . " while processing attribute '$attrName'");
                            return false;
                        }
                        // Pass the DB value to the object
                        $obj->fromDB($dbResult[$dbAttrName]);
                        // Store the object in our attributes
                        $this->set($attrName, $obj);
                        break;
                }
            }
        }

        return true;
    }

    protected function setAttrsFromMultiDBResult($dbResult, $mapping = null, $as = null) {
        $tableName = ($mapping == null ? $this->tableName : ($as == null ? 'Base' : $as));
        // look at each of our attributes
        foreach($this->getAttributes(true) as $attrName => $attrProps) {
            if($attrProps['commit'] == self::COMMIT_FIRST)
                $this->changeAttribute($attrName, 'commit', self::COMMIT_CHANGED);
            // if there is a result in the database from that attribute
            if(isset($dbResult[$tableName . '.' . $attrName])) {
                // Decide on how to copy each attribute's DB value to the object,
                // based on the attribute's type
                switch($attrProps['type']) {
                    case 'int':
                    case 'string':
                    case 'float':
                    case 'time':
                        // Set the object value directly from the DB value
                        $this->set($attrName, $dbResult[$tableName . '.' . $attrName]);
                        if(count($attrProps['foreign']) > 0) {
                            $cls = $this->getAttributeType($attrProps['foreign']['object']); //$attrProps['type'];
                            $obj = new $cls();
                            if ($obj == null) {
                                $this->setError("Could not instantiate class '$cls'"
                                        . " while processing attribute '$attrName'");
                                return false;
                            }
                            $obj->populateWith($dbResult, $mapping, "Base.{$attrProps['foreign']['object']}");
                            // Store the object in our attributes
                            $this->set($attrProps['foreign']['object'], $obj);
                        }
                        break;
                    default:
                        // Create a new instance of the class specified by the attribute type
                        $cls = $this->attrProps['type'];
                        $obj = new $cls();
                        if ($obj == null) {
                            $this->setError("Could not instantiate class '$cls'"
                                    . " while processing attribute '$attrName'");
                            return false;
                        }
                        // Pass the DB value to the object
                        $obj->fromDB($dbResult[$tableName . '.' . $attrName]);
                        // Store the object in our attributes
                        $this->set($attrName, $obj);
                        break;
                }
            }
        }

        return true;
    }

    public function populateFromResults($results) {
        return $this->setAttrsFromDBResult($results);
    }

    public function populateFromResultsMulti($results, $mapping = null, $as = null) {
        return $this->setAttrsFromMultiDBResult($results, $mapping, $as);
    }

    public function commit($updateObj = false) {
        // Get the DBI used by this object
        $DBI = $this->DBI;

        // Delete an object marked for deletion
        if($this->isMarkedForDeletion()) {
            if(!$this->isStored()) {
                $this->setError('Attempted to delete an object that is not stored.');
                return false;
            }
            $DBI->startTransaction($updateObj ? null : array($this, 'finishDelete'));
            if(!$DBI->delete($this->getTableName(), $this->getConstraintForPrimaryKey())) {
                $DBI->cancelTransaction();
                return false;
            }
            if(!$this->onDelete()) {
                $DBI->cancelTransaction();
                return false;
            }
            // this is what we call playing with fire
            //   if the transaction fails, we are left with a dead object...
            if($updateObj)
                $this->finishDelete(true);
            $DBI->commitTransaction();
            return true;
        }

        // Check object's validity
        if(!$this->isValid())
            return false;

        if($this->isStored() || $this->_inTransaction) {
            // UPDATE an object that exists in the DB
            $DBI->startTransaction($updateObj ? null : array($this, 'finishUpdate'));
            list($okay, $reset, $what) = $this->prepareUpdate(true);
            if(!$okay) {
                $DBI->cancelTransaction();
                return false;
            }
            if(count($what) > 0) {
                if(($constraints = $this->getConstraintForPrimaryKey(true)) === false ||
                    !$DBI->update($this->getTableName(), $what, $constraints))
                {
                    $DBI->cancelTransaction();
                    return false;
                }
                if(!$this->onUpdate($what)) {
                    $DBI->cancelTransaction();
                    return false;
                }
            }

            $this->_reset = $reset;
            if($updateObj)
                $this->finishUpdate(true);
        }
        else {
            // INSERT an object that does not exist in the DB
            $DBI->startTransaction($updateObj ? null : array($this, 'finishInsert'));
            list($okay, $reset, $what) = $this->prepareUpdate(false);
            if(!$okay) {
                $DBI->cancelTransaction();
                return false;
            }
            if(($result = $DBI->insert($this->getTableName(), $what)) === false) {
                $DBI->cancelTransaction();
                if ($DBI->hasError) {
                    $DBIerror = $DBI->getError();
                    $this->setError("DBI Error: ".$DBIerror[0]);
                }
                return false;
            }
            // Set the primary key from the insert id
            $pk = $this->getPrimaryKey();
            if($pk && ($this->primaryKeyIsAuto && !is_array($pk)))
                $this->set($pk, $result);

            if(!$this->onInsert($what)) {
                $DBI->cancelTransaction();
                return false;
            }

            $this->_reset = $reset;
            if($updateObj)
                $this->finishInsert(true);
        }

        $this->_inTransaction = true;

        $DBI->commitTransaction();

        return true;
    }

    public function finishDelete($status) {
        if(!$status)
            return;

        $this->onDeleteFinish();
        $this->nullify();
    }

    public function finishUpdate($status) {
        // mark that we are done with the transaction, whether it succeeded or not
        $this->_inTransaction = false;

        if(!$status)
            return;

        // set COMMIT_FIRST attributes to COMMIT_CHANGED as per their definition
        foreach($this->_reset as $r)
            $this->changeAttribute($r, 'commit', self::COMMIT_CHANGED);

        $this->updateBase();

        $this->onUpdateFinish();
    }

    public function finishInsert($status) {
        $this->_inTransaction = false;

        if(!$status)
            return;

        // set COMMIT_FIRST attributes to COMMIT_CHANGED as per their definition
        foreach($this->_reset as $r)
            $this->changeAttribute($r, 'commit', self::COMMIT_CHANGED);

        $this->updateBase();

        $this->onInsertFinish();
    }

    protected function prepareUpdate($isUpdate) {
        // Which fields are going to be updated/inserted (field name => value to be updated/inserted)
        $what = array();

        // Which attributes need to have their 'commit' property set from COMMIT_FIRST to COMMIT_CHANGED
        $reset = array();

        // Non-fatal errors set this to false so we don't go ahead with the commit
        $okay = true;

        foreach($this->getAttributes(true) as $attrName => $attrProps) {
            switch($attrProps['commit']) {
                case self::COMMIT_NEVER:
                case self::COMMIT_FOREIGN:
                case self::COMMIT_NOSOURCE:
                    continue 2;
                case self::COMMIT_FIRST:
                    $reset[] = $attrName;
                    if(!$isUpdate)
                        break;  // don't fall through if this is an INSERT
                case self::COMMIT_CHANGED:  // fall-through, because COMMIT_FIRST acts like COMMIT_CHANGED for
                                            //    existing objects (only acts like COMMIT_ALWAYS on INSERT)
                    if($attrProps['type'] != 'int' && $attrProps['type'] != 'string' && $attrProps['type'] != 'float'
                        && $attrProps['type'] != 'time')
                    {
                        $obj = $this->get($attrName);
                        if($obj instanceof SModel2 && !$obj->isDirty())
                            continue 2;
                    }
                    else if(count($attrProps['foreign']) > 0) {
                        $tgt = $this->get($attrProps['foreign']['object']);
                        if($tgt != null) {
                            if(!($tgt instanceof SDatabaseModel))
                                continue 2;
                            if(!$tgt->isDirty() && $this->get($attrName) == $tgt->get($attrProps['foreign']['on']))
                                continue 2;
                        }
                    }
                    else if(!$this->isChanged($attrName))
                        continue 2;
                    break;
            }
            switch($attrProps['type']) {
                case 'int':
                case 'float':
                case 'string':
                    if($attrProps['array']) {
                        $this->setError('Cannot commit an array to a database field.');
                        $okay = false;
                    }
                    else if(count($attrProps['foreign']) > 0) {
                        $tgt = $this->get($attrProps['foreign']['object']);
                        if($tgt && $tgt instanceof SDatabaseModel) {
                            if(!$tgt->commit()) {
                                $this->getErrorFrom($tgt);
                                $this->setError("Failed to commit child entity for $attrName; bailing");
                                return array(false, array(), array());
                            }
                            $fKey = $tgt->get($attrProps['foreign']['on']);
                            if($fKey != $this->get($attrName)) {
                                $this->set($attrName, $fKey);
                                $what[$attrName] = $fKey;
                            }
                        }
                        else
                            $what[$attrName] = $this->get($attrName);
                    }
                    else
                        $what[$attrName] = $this->get($attrName);
                    break;
                case 'time':
                    if($attrProps['array']) {
                        $this->setError('Cannot commit an array to a database field.');
                        $okay = false;
                    }
                    else {
                        $val = $this->get($attrName);
                        if(is_array($val))
                            $val = $val[0];
                        if(strtolower($val) == 'now()' || strtolower($val) == 'current_timestamp')
                            $what[$attrName] = array($val);
                        else
                            $what[$attrName] = $val;
                    }
                    break;
                default:
                    if($attrProps['array']) {
                        $this->setError('Cannot commit an array of objects to a database field.');
                        $okay = false;
                    }
                    else {
                        $obj = $this->get($attrName);
                        if($obj instanceOf SModel2) {
                            if(!$obj->commit())
                                $this->getErrorFrom($obj);
                            else {
                                $this->set($fieldToUpdate, $obj->get($obj->getPrimaryKey()));
                                $what[$fieldToUpdate] = $this->get($fieldToUpdate);
                            }
                        }
                    }
                    break;
            }
        }

        return array($okay, $reset, $what);
    }

    public function getConstraintForPrimaryKey($skipStorageCheck = false) {
        if(!$skipStorageCheck && !$this->isStored()) {
            $this->setError('I am not stored!  Probably an internal error...');
            return false;
        }
        if($this->primaryKey == '') {
            $this->setError('No primary key set; cannot commit');
            return false;
        }
        // If we have multiple primary keys for an object
        if (is_array($this->primaryKey)) {
            $return = array();
            foreach($this->primaryKey as $pk) {
                $return[$pk] = $this->get($pk);
            }
            return $return;
        }
        // If we have just one primary key
        else
            return array($this->primaryKey => $this->get($this->primaryKey));
    }

    public function copy($asNew = false) {
        $obj = parent::copy($asNew);

        if(!$obj)
            return null;

        // reset primary key value(s)
        if($asNew) {
            // DON'T reset the primary key value if it's an array because it's probably not auto-increment
            //   and will need to be set manually before committing
            if(!is_array($obj->primaryKey))
                $obj->set($this->primaryKey, $obj->getAttributeDefault($this->primaryKey), false);
        }

        return $obj;
    }

    protected static function getListBase($DBI, $constraints, $limit, $order, $count, $objClass, $asObjects = true,
                                            $extraJoins = array(), $groupBy = array(), $extraAttrs = array())
    {
        STimer::startAvg('getList');
        STimer::startAvg('getList:overhead');

        $sq = new SQuery();
        $sq->setBaseClass($objClass);
        $sq->setMode(SQuery::MODE_PREFIX);
        $sq->setCriteria($constraints);
        $sq->setLimit($limit);
        $sq->setOrder($order);
        $sq->setCount($count);
        $sq->setExtraJoins($extraJoins);
        $sq->setExtraAttrs($extraAttrs);
        $sq->setGroupBy($groupBy);

        $query = $sq->buildQuery();
        if($query === false) {
            self::setStaticError('Error building query');
            return null;
        }

        $results = $DBI->query($query);
        if($results === null) {
            self::setStaticError('Error during getList()');
            return null;
        }

        if ($count) {
            $row = $results->nextRow();
            return $row['COUNT(*)'];
        }

        $attrs = null;
        if($asObjects) {
            $objects = array();
            while(($r = $results->nextRow())) {
                STimer::startAvg('getList:item');
                $obj = new $objClass;
                if($attrs === null)
                    $attrs = $obj->getAttributes();
                foreach($attrs as $a) {
                    if(isset($r['Base.' . $a]))
                        $obj->set($a, $r['Base.' . $a]);
                }
                $obj->updateBase();
                $objects[] = $obj;
                STimer::endAvg('getList:item');
            }
            STimer::endAvg('getList');
            return $objects;
        }
        else {
            STimer::endAvg('getList');
            return $results;
        }
    }

    protected static function getListBaseMulti($DBI, $constraints, $limit, $order, $count, $objClass, $asObjects = true,
                                                $depth = 1, $extraJoins = array(), $groupBy = array(),
                                                $extraAttrs = array(), $extraTables = array())
    {
        STimer::startAvg('getListMulti');
        STimer::startAvg('getListMulti:overhead');

        $sq = new SQuery();
        $sq->setBaseClass($objClass);
        $sq->setMode(SQuery::MODE_MULTI);
        $sq->setDepth($depth);
        $sq->setCriteria($constraints);
        $sq->setLimit($limit);
        $sq->setOrder($order);
        $sq->setCount($count);
        $sq->setGroupBy($groupBy);
        $sq->setExtraJoins($extraJoins);
        $sq->setExtraTables($extraTables);
        $sq->setExtraAttrs($extraAttrs);

        $query = $sq->buildQuery();
        if($query === false) {
            self::setStaticError('Error building query');
            return null;
        }

        $result = $DBI->query($query);
        if(!$result) {
            self::setStaticError("Error during getListMulti()");
            return null;
        }
        STimer::endAvg('getListMulti:overhead');

        if($count) {
            $row = $result->nextRow();
            return $row['COUNT(*)'];
        }

        if($objClass != '') {
            $objects = array();
            self::$_cache = array();
            while(($r = $result->nextRow())) {
                STimer::startAvg('getListMulti:item');
                $obj = new $objClass();
                $obj->populateWith($r, $sq->getMapping(), 'Base');
                $objects[] = $obj;
                STimer::endAvg('getListMulti:item');
            }
            self::$_cache = array();
            STimer::endAvg('getListMulti');
            return $objects;
        }
        else {
            STimer::endAvg('getListMulti');
            return array($result, $mapping);
        }
    }

    /*
     * @brief Get an array of instances of this class that meet a set of $constraints
     * @param $constraints [array]: The constraints that returned objects must satisfy
     * @return [array]: The set of matching objects
     *
     * This should be implemented as a static function in actual model classes. Implementations
     * of the method should call getListBase() to do all the actual work of building
     * the list.
     */
//  public abstract function getList($constraints = array(), $limit = array(), $order = array());

    protected function onDelete() {
        return true;
    }

    protected function onDeleteFinish() {
    }

    protected function onInsert($what) {
        return true;
    }

    protected function onInsertFinish() {
    }

    protected function onUpdate($what) {
        return true;
    }

    protected function onUpdateFinish() {
    }

    /* ----------------------------------------------- */
    /* FUNCTIONS FOR HANDLING FOREIGN STORAGE OF OBJECT
    /* ----------------------------------------------- */

    public function toDB() {
        return $this->get($this->primaryKey);
    }

    public function fromDB($rep) {
        $this->populate($rep);
    }

    public function getFormatted($field, $format) {
        if(!$this->attributeExists($field)) {
            $this->setError('No such field \'' . $field . '\'');
            return false;
        }
        return DBI2::formatTimestamp($this->$field, $format);
    }

    public function setFormatted($field, $newValue) {
        if(!$this->attributeExists($field)) {
            $this->setError('No such field \'' . $field . '\'');
            return false;
        }
        $formattedVal = strftime("%F %T", strtotime($newValue));
        $this->$field = $formattedVal;
        return true;
    }

    public function getXML($options = array()) {
        if(!isset($options['root']))
            $options['root'] = $this->tableName;
        return parent::getXML($options);
    }

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

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

    protected function registerDBI($DBI) {
        if(!is_object($DBI) || !($DBI instanceof DBI2)) {
            $this->setError('DBI must be object and instance of DBI2!');
            return false;
        }
        $this->DBI = $DBI;
        return true;
    }

    protected function registerTableName($tableName) {
        $this->tableName = $tableName;
    }

    protected function registerPrimaryKey($primaryKey, $isAuto = true) {
        $this->primaryKeyIsAuto = $isAuto ? true : false;
        $this->primaryKey = $primaryKey;
    }

    public static function isDatabaseAttributeStatic($info) {
        if(!((isset($info['type']) && $info['type'] != 'int' && $info['type'] != 'string'
            && $info['type'] != 'float' && $info['type'] != 'time')
            || (isset($info['commit']) && $info['commit'] == SModel2::COMMIT_NOSOURCE)
            || (isset($info['array']) && $info['array'] == true)))
            return true;
        else
            return false;
    }

    public function isDatabaseAttribute($attrName) {
        $info = $this->getAttributeInfo($attrName);
        return self::isDatabaseAttribute_int($info);
    }

    public function attributesToSQL($objName, $multi = false, $prefix = null) {
        $sq = new SQuery;

        $sq->setBaseClass($objName);
        if($multi)
            $sq->setMode(SQuery::MODE_MULTI);
        else if($prefix != null) {
            $sq->setMode(SQuery::MODE_PREFIX);
            $sq->setPrefix($prefix);
        }
        else
            $sq->setMode(SQuery::MODE_SINGLE);

        $sq->buildMapping();

        return $sq->getAttributeList();
    }
}

?>

---