SWAT/model/SModel.php5

<?php
class SModel extends SObject {
    private $DBI = "";
    private $entity;
    private $isMarkedForDeletion = false;
    private $touchedValues = array();

    public function __construct($id = "") {
        global $DBI;

        // set the name of the database entity to the name of the class
        // with the first letter lowercased
        $class = get_class($this);
        $this->setEntity($this->lowercaseFirst($class));

        // set the DBI to the global DBI
        if (isset($DBI)) {
            $this->setDBI($DBI);
        }

        // auto-populate if a value is passed in
        if ($id !== ""){ $this->populate($id); }
        else { $this->reset(); }

        return true;
    }

    public function getAttributes() {
        return array();
    }

    public function getUniqueAttributes() {
        return array();
    }



    /* -------------------------------------------- */
    /* Database Synchronization */
    /* -------------------------------------------- */

    public function populate($id = "") {

        // check to make sure this object is error-free
        if (count($this->getError()) > 0){
            $this->setError($this->getFailedString('populate')
                            . "Object error count is non-zero.");
            return false;
        }

        // get the populate attributes for this class
        $uas = $this->getUniqueAttributes();
        if (count($uas) < 1) {
            $this->setError($this->getFailedString('populate')
                            . "No unique attributes specified.");
            return false;
        }

        $pai = 0;           // populating attribute index
        $pa = $uas[$pai];   // populating attribute

        // while a populate attribute is not found,
        // use the next available.
        while ($id === "" && ($pai + 1) < count($uas)) {
            $pai++;
            if (isset($uas[$pai])){
                $pa = $uas[$pai];
                $getFn = $this->getFunctionFromEntity($pa);
                $id = $this->$getFn();
            }
        }

        // if object did not give us an id, set an error
        if ($id === "") {
            $this->setError($this->getFailedString('populate')
                            . "No populate attribute was set.");
            return false;
        }

        // set the 'where' condition based on what field we are
        // using to populate
        $whereCond = "$pa = '" . $id . "'";

        // if we have a foreign key(s), we want to do a left join
        $fkinfo = $this->getForeignKey();
        if($fkinfo) {
            $query = "SELECT " . implode(", ", array_map(array($this, 'preAppendEntity'), $this->getAttributes()))
                        . " FROM " . $this->getEntity();
            foreach($fkinfo as $fkitem) {
                $query .= " LEFT JOIN " . $fkitem['table'] . " ON " . $this->getEntity() . "." . $fkitem['foreignkey']
                            . " = " . $fkitem['table'] . "." . $fkitem['tablekey'];
            }
            $query .= " WHERE " . $whereCond . " LIMIT 1;";
        } else {
            // build the query
            $query = "SELECT "
                    . implode(", ",
                array_map(array($this, 'preAppendEntity'), $this->getAttributes()))
                    . " FROM " . $this->getEntity() . " WHERE "
                    . $whereCond
                    . " LIMIT 1;";
        }

        // check to see if the database exists, and if it has
        // any errors thrown.
        if ($this->DBIHasNoError('populate') == false){
            return false;
        }

        // do the query
        $result = $this->getDBI()->query($query);

        // check for errors after query as well
        if ($this->DBIHasNoError('populate',
                'Error performing populate query.') == false){
            return false;
        }

        // if there are no fields in the database
        // matching this object, throw an error
        if (count($result) != 1){
            $this->setError($this->getFailedString('populate')
                            . "Record matching $pa $id not found.");
            return false;
        }

        // if we've arrived at this point, the populate request was
        // valid and the query was successful. Store the values
        // in the object.
        $tmp = $this->getAttributes();
        $tmp = array_map(array($this,'convertAttrFromDB'), $tmp);
        foreach($tmp as $attribute) {
            $setFn = $this->setFunctionFromEntity($attribute);
            $this->$setFn($result[0][$attribute]);
        }

        // Clear out touched values so it will only be filled with values
        // that were changed with set
        $this->touchedValues = array();
        //success!
        return true;
    }

    public function getForeignKey() {
        return false;
// In derived classes, we want to do the following:
//      return array(array('table' => 'foo', 'foreignkey' => 'bar', 'tablekey' => 'baz'));
                                                            // return array of triplets of table (table to join with),
                                                            //   foreign key (which key in OUR table to use as foreign key),
                                                            //   and the key in the foreign table which matches our foreign key
    }

    protected function preAppendEntity($value) {
        if(strpos($value, ".")) {
            $tmp = explode(".", $value);
            return $value . " AS " . $tmp[0] . "_" . $tmp[1];
        }
        else {
            return $this->getEntity() . "." . $value;
        }
    }

    public function commitForeign($table, $unique, $attributes, $foreignKey) {
        // check to make sure this object is error-free
        if (count($this->getError()) > 0){
            $this->setError($this->getFailedString('commitForeign')
                            . "Object error count is non-zero.");
            print "foo <br />\n";
            return false;
        }
        $priKey = $unique;

        // get the function by which we fetch our
        // primary key
        $getIdFn = $this->getFunctionFromEntity($priKey);
        $setIdFn = $this->setFunctionFromEntity($priKey);
//      print "getIdFn = $getIdFn<br />\n";
        $attrs = explode(", ", $attributes);
        $values = array();

        foreach($attrs as $attr) {
            $getValueFn = $this->getFunctionFromEntity($attr);
            array_push($values, "$attr = '" . SWATFunctions::safeSql($this->$getValueFn())
                . "'");
        }

        if ($this->$getIdFn() == "") {
            // build the query
            $query = "INSERT INTO " . $table . " SET "
                    . implode(", ", $values)
                    . ";";

            print "commitForeign query (inserting): $query <br />\n";
            // run the query
            $result = $this->getDBI()->query($query);

            // check for errors
            if ($this->DBIHasNoError('commitForeign',
                    'Query to insert new record failed.') == false){
                return false;
            }

            // set the item id to the insert id from the
            // insert query that was just run
            $this->$setIdFn($this->getDBI()->mysql_insert_id());
            $setFnKey = $this->setFunctionFromEntity($foreignKey);
            $this->$setFnKey($this->$getIdFn());

            return true;
        }

        // if ID is not blank, we'll do an update.

        // build the query
        $query = "SELECT " . $priKey . " FROM " . $table
                . " WHERE " . $priKey . " = '" . SWATFunctions::safeSql($this->$getIdFn())
                . "'  LIMIT 1;";

        print "commitForeign query (update 1): $query <br />\n";

        // run the query
        $result = $this->getDBI()->query($query);

        // check for errors
        if ($this->DBIHasNoError('commitForeign',
                'Query to check for existing record failed.') == false){
            return false;
        }

        // check to see if record to update was found in the database.
        // if not, throw an error-- id value for object is invalid.
        if (count($result) != 1) {
            $this->setError($this->getFailedString('commitForeign')
                . "Can't commit this object; record with $priKey = "
                . $this->$getIdFn() . " is not found.");
            return false;
        }

        // if we get past error checking, id is valid, so we
        // can build the update query for the commit
        $query = "UPDATE " . $table . " SET "
            . implode(", ", $values)
            . " WHERE " . $priKey
            . " = '" . SWATFunctions::safeSql($this->$getIdFn()) . "';";

        print "commitForeign query (update 2): $query <br />\n";

        // run the query
        $result = $this->getDBI()->query($query);

        // check for errors
        if ($this->DBIHasNoError('commitForeign',
                "Query to update existing record with $priKey = "
                . $this->$getIdFn() . "failed.") == false){
            return false;
        }

        //success!
        return true;
    }

    public function commit() {

        // check to make sure this object is error-free
        if (count($this->getError()) > 0){
            $this->setError($this->getFailedString('commit')
                            . "Object error count is non-zero.");
            return false;
        }

        // CHECK FOR OTHER POSSIBLE ERRORS:
        // --------------------------------------

        // make sure that the object has 'populate' attributes
        // the first one will be used as the primary key
        // for committing the object
        $uas = $this->getUniqueAttributes();
        if (count($uas) < 1) {
            $this->setError($this->getFailedString('commit')
                            . "No unique attributes specified.");
            return false;
        }

        // make sure the object also has attribtues to commit!
        $as = $this->getAttributes();
        if (count($as) < 1) {
            $this->setError($this->getFailedString('commit')
                            . "No attributes specified.");
            return false;
        }

        if (!$this->isValidObject()){
            $this->setError($this->getFailedString('commit')
                            . "Valid object check fails.");
            return false;
        }

        // DEFINE VARIABLES TO BE USED IN COMMIT:
        // --------------------------------------
        $priKey = $uas[0];

        // get the function by which we fetch our
        // primary key
        $getIdFn = $this->getFunctionFromEntity($priKey);
        $setIdFn = $this->setFunctionFromEntity($priKey);

        // enumerate all the update/insert values
        $values = array();

        // DERIVE ALL THE UPDATE SQL PAIRS FOR THE QUERY
        // ---------------------------------------------

        foreach($as as $a) {
            // if this is the primary key, don't include it in the update
            if ($a == $priKey) continue;
//          print "Looking at attribute $a<br />\n";
            if (strpos($a, ".") > 0) {
//              print "Skipping foreign attribute $a<br />\n";
                continue;   // foreign attributes not included
            }

            // get the accessor function for the attribute value
            $getValueFn = $this->getFunctionFromEntity($a);

            // push the SQL pair onto the values array

            // If we have a null value, decide whether or not to put "NULL" into the
            // query. We want to have an explicit null there if we want to write over
            // an existing value. But we don't want to put NULL if we want the DB to
            // use a default value for a field that's not yet set.
            if($this->$getValueFn() === null){
                // If the value has been "touched", i.e., specifically SET as null, then
                if (isset($this->touchedValues[$a])) {
                    // as long as the value is not one of the unique attributes
                    // (which should never be set to null), we should put a
                    // set to NULL into the query
                    if (!in_array($a, $uas)) {
                        array_push($values, "$a = NULL");
                    }
                }
            } else {
                array_push($values, "$a = '"
                            . SWATFunctions::safeSql($this->$getValueFn())
                            . "'");
            }
        }

        // check to see if the database exists, and if it has
        // any errors thrown.
        if ($this->DBIHasNoError('commit') == false){
            return false;
        }

        // CREATE THE ACTUAL QUERIES
        // -------------------------

        // if Id is blank, insert
        if ($this->$getIdFn() == "") {

            // build the query - start with insert into tablename
            $query = "INSERT INTO " . $this->getEntity();
            // if there are more than 0 values (at least one non-null)
            // insert those values using a SET statement
            if (count($values) > 0){
                 $query .= " SET "
                    . implode(", ", $values);
            // otherwise, insert an empty row that will take the default values
            } else {
                $query .= " VALUES ()";
            }
            // end the query
            $query .= ";";


            //print($query);

            // run the query
            $result = $this->getDBI()->query($query);

            // check for errors
            if ($this->DBIHasNoError('commit',
                    'Query to insert new record failed.') == false){
                return false;
            }

            // set the item id to the insert id from the
            // insert query that was just run
            $this->$setIdFn($this->getDBI()->mysql_insert_id());

    //      print "Committed new with key
//".$this->getDBI()->mysql_insert_id()."<br />\n";
            return true;
        }

        // if ID is not blank, we'll do an update.

        // build the query
        $query = "SELECT " . $priKey . " FROM " . $this->getEntity()
                . " WHERE " . $priKey . " = '" . SWATFunctions::safeSql($this->$getIdFn()) . "'"
                . " LIMIT 1;";

        // run the query
        $result = $this->getDBI()->query($query);

        // check for errors
        if ($this->DBIHasNoError('commit',
                'Query to check for existing record failed.') == false){
            return false;
        }

        // check to see if record to update was found in the database.
        // if not, throw an error-- id value for object is invalid.
        if (count($result) != 1) {
            $this->setError($this->getFailedString('commit')
                . "Can't commit this object; record with $priKey = "
                . $this->$getIdFn() . " is not found.");
            return false;
        }

        if ($this->isMarkedForDeletion) {
            // if we get past error checking, id is valid, so we
            // can build the update query for the commit
            $query = "DELETE FROM " . $this->getEntity()
                . " WHERE " . $this->preAppendEntity($priKey)
                . " = '" . SWATFunctions::safeSql($this->$getIdFn()) . "';";

        } else {

            // if we get past error checking, id is valid, so we
            // can build the update query for the commit
            $query = "UPDATE " . $this->getEntity() . " SET "
                . implode(", ", $values)
                . " WHERE " . $this->preAppendEntity($priKey)
                . " = '" . SWATFunctions::safeSql($this->$getIdFn()) . "';";
        }

        // run the query
        $result = $this->getDBI()->query($query);

        // check for errors
        if ($this->DBIHasNoError('commit',
                "Query to update existing record with $priKey = "
                . $this->$getIdFn() . "failed.") == false){
            return false;
        }

        //success!
        return true;
    }

/*  protected function buildCommitQuery($method, $values) {
        switch($method) {
            case 'insert':
                return $this->buildUpdateQuery(;
            case 'update':
                return "";
            default:
                return "";
        }
    }*/

    public function isValidObject() {
        return true;
    }

    public function reset() {
        $as = $this->getAttributes();
        foreach($as as $attribute) {
            /*
            if(!(strpos($attribute, ".") == false)){
//              print "Well well well <br />\n";

                $attribute = substr($attribute, strpos($attribute, ".") + 1);
//              print "Attribute is now $attribute<br />\n";
            }
            */
            $setFn = $this->setFunctionFromEntity($attribute);
            $this->$setFn(null);
        }
        $this->isMarkedForDeletion = false;
        $this->touchedValues = array();
    }

    protected function getFailedString($action) {
        return "Attempt to $action " . get_class($this) . " failed: ";
    }

    // converts, e.g., media_something to media.something
    public function convertAttrToDB($attr) {
        if(strpos($attr, "_")) {
            return preg_replace("/_/", ".", $attr);
        }
        else
            return $attr;
    }

    // converts, e.g., media.something to media_something
    public function convertAttrFromDB($attr) {
        if(strpos($attr, ".")) {
            return preg_replace("/\./", "_", $attr);
        }
        else
            return $attr;
    }

    public function getAllAttributes() {
        $ret = array();
        foreach($this->getAttributes() as $attr) {
            $getFn = $this->getFunctionFromEntity($attr);
            $attrVal = $this->$getFn();
            $ret[$attr] = $attrVal;
        }
        return $ret;
    }

    /* -------------------------------------------- */
    /* Object List Functions */
    /* -------------------------------------------- */

    public function getListQuery( $criteria ) {

        $keys = array_keys($criteria);
        $attributes = $this->getAttributes();
        $where_clause = " WHERE";
        $limit_clause = "";
        $order_clause = "";
        $data = array();
        $elements = array();
        $constraints = false;

        // check if the array keys passed in are valid attributes of the calling object
        foreach( $keys as $key )
        {
            if ($key == "limit") {
                $limit_clause = " LIMIT " . $criteria[$key];
            } else if ($key == "order") {
                $order_clause = " ORDER BY " . $criteria[$key];
            } else if( in_array($key, $attributes) ) {
                $constraints = true;
                // if the current looping key is valid, push it in an
                // array for constructing a part of later SQL query string
                // (e.g. $where_clause)
                if(!is_array($criteria[$key])){
                    if ($criteria[$key] === null) {
                        $element = " " . $key . " IS NULL ";
                    } else {
                        $element = " " . $key . "= '" . $criteria[$key] . "' ";
                    }
                } else {
                    $element = " " . $key . $criteria[$key][1] . "'" . $criteria[$key][0] . "' ";
                }
                array_push( $elements, $element );
                continue;
            }
            else
            {
                $this->setError( $key . " attribute passed into getListQuery() may be invalid" );
                return false;
            }

        }
        // constructing the 'WHERE' clause
        $where_clause .= implode( 'AND', $elements );

        // get the populate attributes for this class
        $uas = $this->getUniqueAttributes();
        if (count($uas) < 1)
        {
            $this->setError($this->getFailedString('getListQuery')
                            . "No unique attributes specified.");
            return false;
        }
        $uniqueId = $uas[0];

        // query the database based on specification of $criteria
        $query = "SELECT " . $uniqueId .
             " FROM " . $this->getEntity();


        if ($constraints) $query .= $where_clause;
        $query .=  $order_clause . $limit_clause . ";";

        //echo $query;

        //print($query);
        // check to see if the database exists, and if it has
        // any errors thrown.
        if ($this->DBIHasNoError('getList') == false){
            return false;
        }

        $result = $this->DBI->query($query);

        // push the returned database result into an array $data
        $className = get_class($this);
        for( $i = 0; $i < count($result); $i++ ) {
            $newObject = new $className();

            $newObject->setDBI($this->getDBI());
            $newObject->populate($result[$i][$uniqueId]);
            $data []= $newObject;
        }

        return ($data);
    }

    public function getList($criteria = "", $nullable = false) {
        $allowedInEq = array(">",">=","<","<=","=","<>");
        if ($criteria == "") $criteria = array();
        assert(is_array($criteria));
        $keys = array_keys($criteria);


        foreach($keys as $key) {
            if($nullable == false){
                if (!isset($criteria[$key])){
                    $this->setError( "attribute $key in the passed parameters is not set" );
                    return false;
                }
            }

            //if it is an array
            if(is_array($criteria[$key])){
                //you shouldn't be searching for values greater than or less than null
                // so this always executes
                if(!isset($criteria[$key][0]) || !isset($criteria[$key][1])){
                    $this->setError( "attribute $key in the passed parameters is not set" );
                    return false;
                } else if (array_search($criteria[$key][1],$allowedInEq) === false){
                    $this->setError( "invalid equality test in $key" );
                    return false;
                }
            }
        }

        // get the populate attributes for this class
        $uas = $this->getUniqueAttributes();
        if (count($uas) < 1) {
            $this->setError($this->getFailedString('getListQuery')
                            . "No unique attributes specified.");
            return false;
        }
        $uniqueId = $uas[0];

        if (count($criteria) == 0){
            // fetch all resources.

            $data = array();
            $query = "SELECT " . $uniqueId . " FROM " . $this->getEntity() . ";";
//          print($query);
            $result = $this->DBI->query($query);
            $className = get_class($this);

            for ($i = 0; $i < count($result); $i++) {
                $newItem = new $className();
                $newItem->setDBI($this->DBI);
                $newItem->populate($result[$i][$uniqueId]);
                if ($newItem->hasError()){
                    $this->setPrettyError('getList', 'Could not populate returned object.');
                }
                array_push($data, $newItem);
            }
            return ($data);
        } else {
            // $criteria is not empty, call 'getListQuery'
            return $this->getListQuery( $criteria );
        }
    }

    public function superGetList($criteria, $order = "", $limit = ""){
        $attrib = $this->getAttributes();

        $uas = $this->getUniqueAttributes();
        if (count($uas) < 1)
        {
            $this->setError($this->getFailedString('getListQuery')
                            . "No unique attributes specified.");
            return false;
        }
        $uniqueId = $uas[0];



        $query = "SELECT " . $uniqueId .
             " FROM " . $this->getEntity() . " ";

        $query .= "WHERE" . self::criteriaToString($criteria, $attrib);

        if($order != ""){
            $query .=  self::orderToString($order, $attrib);
        }
        if($limit != ""){
            $query .= self::limitToString($limit);
        }

        $query .= ";";


        $result = $this->DBI->query($query);


        // push the returned database result into an array $data
        $className = get_class($this);
        $data = array();
        for( $i = 0; $i < count($result); $i++ )
        {
            array_push( $data, new $className($result[$i][$uniqueId]) );
        }

        return ($data);
    }

    public function getByCriteria($criteria) {
        return false;
    }

    /* -------------------------------------------- */
    /* Accessor Methods
    /* -------------------------------------------- */

    // __call() provides overloaded accessor methods
    // will handle calls to accessor functions that
    // don't actually exist. Saves time of writing
    // them for each object!

    protected function doreplace($item) {
        $result = strpos($item, ".");
        if(!$result)
            return $item;
        else {
            return preg_replace("/\./", "_", $item);
    //      return substr($item, $result + 1);
        }
    }

    public function __call($m, $args)
    {
        // if get function is called -------------------------------
        if ((substr($m, 0, 3) == "get") && (strlen($m) > 3)) {
//          print "Calling $m...<br />\n";
            // get the name of the attribtue affected

            $pos = strpos($m, "_");
            if($pos) {
                $tmp = explode("_", substr($m, 3));
                $var = $tmp[0] . "_" . $tmp[1];
                $var2 = $this->lowercaseFirst($tmp[0]) . "_" . $this->lowercaseFirst($tmp[1]);
            }
            else {
                $var = $this->lowercaseFirst(substr($m, 3));
                $var2 = substr($m, 3);
            }

            // either return the value or set an error if the
            // attribute is not found.
            $tmp = $this->getAttributes();
            $tmp = array_map(array($this,'convertAttrFromDB'), $tmp);
//          print_r($tmp);
            if (in_array($var, $tmp)) {
                return $this->$var;
            } else if (in_array($var2, $tmp)) {
                return $this->$var2;
            } else {
                print "No attribute: call was: $m <br />\n";
                print "$var, $var2 <br />\n";
                print_r($tmp);
                print "<br />\n";
                ob_start();
                debug_print_backtrace();
                $bt = ob_get_contents();
                ob_end_clean();
                $bt = preg_replace("/\n/", "<br />\n", $bt);
                print $bt;
                $this->setError("Attribute $var and $var2 not found on this object.");
                return false;
            }


        // if set function is called ------------------------------
        }else if ((substr($m, 0, 3) == "set") && (strlen($m) > 3)) {
//          print "Calling $m...<br />\n";
            // get the name of the attribtue affected
        /*
            $var = $this->lowercaseFirst(substr($m, 3));
            $var2 = substr($m, 3);
        */
            $pos = strpos($m, "_");
            if($pos) {
                $tmp = explode("_", substr($m, 3));
                $var = $tmp[0] . "_" . $tmp[1];
                $var2 = $this->lowercaseFirst($tmp[0]) . "_" . $this->lowercaseFirst($tmp[1]);
            }
            else {
                $var = $this->lowercaseFirst(substr($m, 3));
                $var2 = substr($m, 3);
            }

            // return false if there are no arguments giving the
            // values with which to set the attribtue
            if (count($args) < 1) {
                print "No args: call was: $m <br />\n";
                $this->setError("Call to set attribute $var lacks an argument.");
                return false;
            }

            // either set the value to the first arg, or set an
            // error if the attribute is not found.
            $tmp = $this->getAttributes();
            $tmp = array_map(array($this,'convertAttrFromDB'), $tmp);
//          print_r($tmp);
            if (in_array($var, $tmp)){
                $this->$var = $args[0];
                $this->touchedValues[$var] = true;
            } else if (in_array($var2, $tmp)) {
                $this->$var2 = $args[0];
                $this->touchedValues[$var2] = true;
            } else {
                print "No attribute: call was $m <br />\n";
                $this->setError("Attribute $var and $var2 not found on this object.");
                return false;
            }
        } else {
            $this->setError("Unknown function $m called on object.");
            return false;
        }
    }

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

    protected function setEntity($entity) {
        $this->entity = $entity;
    }

    public function setDBI($DBI) {
        $this->DBI = &$DBI;
    }

    public function markForDeletion() {
        $this->isMarkedForDeletion = true;
    }

    public function unmarkForDeletion() {
        $this->isMarkedForDeletion = false;
    }

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


    // text modifier functions
    // -----------------------

    public function setFunctionFromEntity($entity) {
        $pos = strpos($entity, ".");
        if($pos)
            return "set" . strtoupper(substr($entity, 0, 1)) . substr($entity, 1, $pos - 1)
                    . "_" . strtoupper(substr($entity, $pos + 1, 1))
                    . substr($entity, $pos + 2);
        else
            return "set" . strtoupper(substr($entity, 0, 1)) . substr($entity, 1);
    }

    public function getFunctionFromEntity($entity) {
        $pos = strpos($entity, ".");
        if($pos)
            return "get" . strtoupper(substr($entity, 0, 1)) . substr($entity, 1, $pos - 1)
                    . "_" . strtoupper(substr($entity, $pos + 1, 1))
                    . substr($entity, $pos + 2);
        else
            return "get" . strtoupper(substr($entity, 0, 1)) . substr($entity, 1);
    }

    public function lowercaseFirst($string) {
        return strtolower(substr($string,0,1)) . substr($string, 1);
    }


    // other helper functions
    // ----------------------

    public function DBIHasNoError($function = "<not specified>", $msg = "") {
        // if the database is not found, throw an error
        if  ($this->getDBI() == null) {
            $this->setError($this->getFailedString($function)
                            . "No database was found. $msg");
            return false;
        }

        // if the database reports an error, throw an error
        if (count($this->getDBI()->getError()) > 0) {
            $this->setError($this->getFailedString($function)
                            . "An error was generated when connecting to/ "
                            . "querying the database. $msg");
            $this->setError($this->getDBI()->getError());
            return false;
        }
        return true;
    }



    public static function criteriaToString($arr, $attributes) {
        if(is_string($arr))
            return $arr;
        else if(!is_array($arr)) {
            self::setStaticError('Criteria must be string or array!');
            return false;
        }
        else if(count($arr) == 0)
            return '';

        $collect = "";
        $op = "=";
        $conj = "AND";
        foreach($arr as $k => $v) {
            // if it's numeric, it means it's a non-associative entry (hopefully)
            if(ctype_digit((string) $k)) {
                // if it's a string, then we have an operator or a conjunction
                if(is_string($v)) {
                    switch(strtoupper($v)) {
                        case 'AND':
                        case 'OR':
                            $conj = $v;
                            break;
                        case '=':
                        case '>=':
                        case '<=':
                        case '<':
                        case '>':
                        case '<>':
                        case 'LIKE':
                        case 'LIKE BINARY':
                        case 'IS':
                        case 'IS NOT':
                        case 'IS NULL':
                        case 'IS NOT NULL':
                            $op = $v;
                            break;
                        default:
                            self::setStaticError("Invalid operator or conjunction in criteria: $v");
                            return false;
                    }
                }
                // if it's an array, then we have a sub-expression, which can be recursively evaluated
                else if(is_array($v)) {
                    $res = self::criteriaToString($v, $attributes);
                    if($res === false)
                        return false;
                    if($collect != "")
                        // only add conjunction if we already have something in our string so far
                        $collect .= " $conj " . $res;
                    else
                        $collect .= $res;
                }
                // it's something else, which is not allowed
                else {
                    self::setStaticError("Invalid operator or conjunction in criteria: $v");
                    return false;
                }
            }
            // it's a string, so it's an attribute
            else if(is_string($k)) {
                // check to see if it's a valid attribute
                if(!in_array($k, $attributes)) {
                    self::setStaticError("Invalid field '$k' in criteria");
                    return false;
                }
                // if we have 'attr' => array('a', 'b'), that means that we want to compare 'attr' to
                //   both 'a' and 'b'
                if(is_array($v)) {
                    foreach($v as $value) {
                        // SPECIAL CASE: IS NULL and IS NOT NULL are unary operators, so we ignored 'value'
                        //   it should be noted that it would be stupid to do 'attr' => array('a', 'b') with the operator
                        //   being IS NULL or IS NOT NULL; perhaps we should print a warning?
                        if($op == 'IS NULL' || $op == 'IS NOT NULL') {
                            if($collect != "")
                                $collect .= " $conj $k $op";
                            else
                                $collect = "$k $op";
                        }
                        else {
                            // some other operator; check type of value we're comparing to and then construct string
                            if($collect != "")
                                $collect .= " $conj $k $op '$value'";
                            else
                                $collect = "$k $op '$value'";
                        }
                    }
                }
                else {
                    // no array, but we do the same thing as in the array case, except for a single value
                    if($op == 'IS NULL' || $op == 'IS NOT NULL') {
                        if($collect != "")
                            $collect .= " $conj $k $op";
                        else
                            $collect = "$k $op";
                    }
                    else {
                        if($collect != "")
                            $collect .= " $conj $k $op '$v'";
                        else
                            $collect = "$k $op '$v'";
                    }
                }
            }
        }

        // this could be a subexpression, so surround in parentheses
        if($collect != "")
            $collect = "($collect)";

        return $collect;
    }

    public static function limitToString($limit) {
        if($limit == "" || count($limit) == 0)
            return '';

        if(is_array($limit)) {
            if(count($limit) == 2) {
                if(!ctype_digit((string) $limit[0]) || $limit[0] < 0 || !ctype_digit((string) $limit[1]) || $limit[1] < 0) {
                    self::setStaticError('Invalid limit values');
                    return false;
                }
                return " LIMIT $limit[0], $limit[1]";
            }
            else if(count($limit) == 1) {
                if(!ctype_digit((string) $limit[0]) || $limit[0] < 0) {
                    self::setStaticError('Invalid limit values');
                    return false;
                }
                return " LIMIT $limit[0]";
            }
        }
        else if(ctype_digit((string) $limit)) {
            if($limit < 0) {
                self::setStaticError('Invalid limit values');
                return false;
            }
            return " LIMIT $limit";
        }

        self::setStaticError('Invalid limit array!');
        return false;
    }

    public static function orderToString($order, $attributes) {
        if($order == "" || count($order) == 0)
            return '';

        if(is_array($order)) {
            $orderStr = ' ORDER BY ';
            foreach($order as $key => $value) {
                if(ctype_digit((string) $key)) {
                    if(!in_array($value, $attributes)) {
                        self::setStaticError('Invalid attribute \'' . $value . '\'');
                        return false;
                    }
                    $orderStr .= $value . ', ';
                }
                else {
                    if(!in_array($key, $attributes)) {
                        self::setStaticError('Invalid attribute \'' . $key . '\'');
                        return false;
                    }
                    $value = strtoupper($value);
                    if($value != 'ASC' && $value != 'DESC') {
                        self::setStaticError('Ordering must be ASC or DESC');
                        return false;
                    }
                    $orderStr .= $key . ' ' . $value . ', ';
                }
            }
            return rtrim($orderStr, ', ');
        }
        else if(is_string($order)) { // && in_array($order, $attributes)) {
            return " ORDER BY $order";
        }
        else {
            self::setStaticError('Invalid order by array');
            return false;
        }
    }

    protected function resetTouchedValues() {
        $this->touchedValues = array();
    }

    protected function getTouchedValues() {
        return $this->touchedValues;
    }

    protected function addTouchedValue($key) {
        $this->touchedValues[$key] = true;
    }
}
?>

---