' ;print_r($xx);exit;
            foreach ($keys as $c) {
                //var_dump($c);

                if ($cfg['distinct'] == $c) {
                    $has_distinct = 'DISTINCT( ' . $this->tableName() . '.' . $c . ') as ' . $c;
                    $ret['count'] = 'DISTINCT  ' . $this->tableName() . '.' . $c . '';
                    continue;
                }
                // cols is in our filtered keys...
                $cols = $c;
            }
            // apply our filtered version, which excludes the distinct column.

            $selectAs = empty($cols) ? array() : array(array(array($cols), '%s', false));
        }

        foreach ($keys as $k) {
            $ret['cols'][$k] = $this->tableName() . '.' . $k;
        }


        foreach ($map as $ocl => $info) {
            list($tab, $col) = explode(':', $info);
            // what about multiple joins on the same table!!!

            // if links point to a table that does not exist - ignore.
            if (!isset($dbstructure[$tab])) {
                continue;
            }

            $xx = DB_DataObject::factory($tab);
            if (!is_object($xx) || !is_a($xx, 'DB_DataObject')) {
                continue;
            }
            // skip columns that are excluded.

            // we ignore include here... - as

            // this is borked ... for multiple jions..
            $this->joinAdd($xx, 'LEFT', 'join_' . $ocl . '_' . $col, $ocl);

            if (!empty($cfg['exclude']) && in_array($ocl, $cfg['exclude'])) {
                continue;
            }

            $tabdef = $xx->table();
            $table = $xx->tableName();

            $keys = array_keys($tabdef);


            if (!empty($cfg['exclude'])) {
                $keys = array_intersect($keys, array_diff($keys, $cfg['exclude']));

                foreach ($keys as $k) {
                    if (in_array($ocl . '_' . $k, $cfg['exclude'])) {
                        $keys = array_diff($keys, $k); // removes the k..
                    }
                }
            }

            if (!empty($cfg['include'])) {
                // include will basically be BASECOLNAME_joinedcolname
                $nkeys = array();
                foreach ($keys as $k) {
                    if (in_array(sprintf($ocl . '_%s', $k), $cfg['include'])) {
                        $nkeys[] = $k;
                    }
                }
                $keys = $nkeys;
            }

            if (empty($keys)) {
                continue;
            }
            // got distinct, and not yet found it..
            if (!$has_distinct && !empty($cfg['distinct'])) {
                $cols = array();
                foreach ($keys as $c) {
                    $tn = sprintf($ocl . '_%s', $c);

                    if ($tn == $cfg['distinct']) {
                        $has_distinct = 'DISTINCT( ' . 'join_' . $ocl . '_' . $col . '.' . $c . ')  as ' . $tn;
                        $ret['count'] = 'DISTINCT  join_' . $ocl . '_' . $col . '.' . $c;
                        // var_dump($this->countWhat );
                        continue;
                    }
                    $cols[] = $c;
                }

                if (!empty($cols)) {
                    $selectAs[] = array($cols, $ocl . '_%s', 'join_' . $ocl . '_' . $col);
                }
            } else {
                $selectAs[] = array($keys, $ocl . '_%s', 'join_' . $ocl . '_' . $col);
            }

            foreach ($keys as $k) {
                $ret['cols'][sprintf('%s_%s', $ocl, $k)] = $tab . '.' . $k;
                $ret['join_names'][sprintf('%s_%s', $ocl, $k)] = sprintf('join_%s_%s.%s', $ocl, $col, $k);
            }
        }

        // fill in the select details..
        $this->selectAdd();

        if ($has_distinct) {
            $this->selectAdd($has_distinct);
        }

        foreach ($selectAs as $ar) {
            $this->selectAs($ar[0], $ar[1], $ar[2]);
        }
        // restore links..
        $this->links($pre_links);

        return $ret;
    }

    /**
     * Get the links associate array  as defined by the links.ini file.
     *
     *
     * Experimental... -
     * Should look a bit like
     *       [local_col_name] => "related_tablename:related_col_name"
     *
     * @return   array|null
     *           array       = if there are links defined for this table.
     *           empty array - if there is a links.ini file, but no links on this table
     *           false       - if no links.ini exists for this database (hence try auto_links).
     * @access   public
     * @see      DB_DataObject::getLinks(), DB_DataObject::getLink()
     */

    public function links()
    {
        global $_DB_DATAOBJECT;
        if (empty($_DB_DATAOBJECT['CONFIG'])) {
            $this->_loadConfig();
        }
        // have to connect.. -> otherwise things break later.
        $this->_connect();

        // alias for shorter code..
        $lcfg = &$_DB_DATAOBJECT['LINKS'];
        $cfg = $_DB_DATAOBJECT['CONFIG'];

        if ($args = func_get_args()) {
            // an associative array was specified, that updates the current
            // schema... - be careful doing this
            if (empty($lcfg[$this->_database])) {
                $lcfg[$this->_database] = array();
            }
            $lcfg[$this->_database][$this->tableName()] = $args[0];
        }
        // loaded and available.
        if (isset($lcfg[$this->_database][$this->tableName()])) {
            return $lcfg[$this->_database][$this->tableName()];
        }

        // loaded
        if (isset($lcfg[$this->_database])) {
            // either no file, or empty..
            return $lcfg[$this->_database] === false ? null : array();
        }

        // links are same place as schema by default.
        $schemas = isset($cfg['schema_location']) ?
            array("{$cfg['schema_location']}/{$this->_database}.ini") :
            array();

        // if ini_* is set look there instead.
        // and support multiple locations.
        if (isset($cfg["ini_{$this->_database}"])) {
            $schemas = is_array($cfg["ini_{$this->_database}"]) ?
                $cfg["ini_{$this->_database}"] :
                explode(PATH_SEPARATOR, $cfg["ini_{$this->_database}"]);
        }

        // default to not available.
        $lcfg[$this->_database] = false;

        foreach ($schemas as $ini) {
            $links = isset($cfg["links_{$this->_database}"]) ?
                $cfg["links_{$this->_database}"] :
                str_replace('.ini', '.links.ini', $ini);

            // file really exists..
            if (!file_exists($links) || !is_file($links)) {
                if (!empty($cfg['debug'])) {
                    $this->debug("Missing links.ini file: $links", "links", 1);
                }
                continue;
            }

            // set to empty array - as we have at least one file now..
            $lcfg[$this->_database] = empty($lcfg[$this->_database]) ? array() : $lcfg[$this->_database];

            // merge schema file into lcfg..
            $lcfg[$this->_database] = array_merge(
                $lcfg[$this->_database],
                parse_ini_file($links, true)
            );


            if (!empty($cfg['debug'])) {
                $this->debug("Loaded links.ini file: $links", "links", 1);
            }
        }

        if (!empty($_DB_DATAOBJECT['CONFIG']['portability']) && $_DB_DATAOBJECT['CONFIG']['portability'] & 1) {
            foreach ($lcfg[$this->_database] as $k => $v) {
                $nk = strtolower($k);
                // results in duplicate cols.. but not a big issue..
                $lcfg[$this->_database][$nk] = isset($lcfg[$this->_database][$nk])
                    ? $lcfg[$this->_database][$nk] : array();

                foreach ($v as $kk => $vv) {
                    //var_Dump($vv);exit;
                    $vv = explode(':', $vv);
                    $vv[0] = strtolower($vv[0]);
                    $lcfg[$this->_database][$nk][$kk] = implode(':', $vv);
                }
            }
        }
        //echo '
';print_r($lcfg);exit;

        // if there is no link data at all on the file!
        // we return null.
        if ($lcfg[$this->_database] === false) {
            return null;
        }

        if (isset($lcfg[$this->_database][$this->tableName()])) {
            return $lcfg[$this->_database][$this->tableName()];
        }

        return array();
    }

    /**
     * joinAdd - adds another dataobject to this, building a joined query.
     *
     * example (requires links.ini to be set up correctly)
     * // get all the images for product 24
     * $i = new DataObject_Image();
     * $pi = new DataObjects_Product_image();
     * $pi->product_id = 24; // set the product id to 24
     * $i->joinAdd($pi); // add the product_image connectoin
     * $i->find();
     * while ($i->fetch()) {
     *     // do stuff
     * }
     * // an example with 2 joins
     * // get all the images linked with products or productgroups
     * $i = new DataObject_Image();
     * $pi = new DataObject_Product_image();
     * $pgi = new DataObject_Productgroup_image();
     * $i->joinAdd($pi);
     * $i->joinAdd($pgi);
     * $i->find();
     * while ($i->fetch()) {
     *     // do stuff
     * }
     *
     *
     * @param bool $obj object |array    the joining object (no value resets the join)
     *                                          If you use an array here it should be in the format:
     *                                          array('local_column','remotetable:remote_column');
     *                                             if remotetable does not have a definition, you should
     *                                             use @ to hide the include error message..
     *                                          array('local_column',  $dataobject , 'remote_column');
     *                                             if array has 3 args, then second is assumed to be the linked dataobject.
     *
     * @param string $joinType string | array
     *                                          'LEFT'|'INNER'|'RIGHT'|'' Inner is default, '' indicates
     *                                          just select ... from a,b,c with no join and
     *                                          links are added as where items.
     *
     *                                          If second Argument is array, it is assumed to be an associative
     *                                          array with arguments matching below = eg.
     *                                          'joinType' => 'INNER',
     *                                          'joinAs' => '...'
     *                                          'joinCol' => ....
     *                                          'useWhereAsOn' => false,
     *
     * @param bool $joinAs string     if you want to select the table as anther name
     *                                          useful when you want to select multiple columsn
     *                                          from a secondary table.
     * @param bool $joinCol string     The column on This objects table to match (needed
     *                                          if this table links to the child object in
     *                                          multiple places eg.
     *                                          user->friend (is a link to another user)
     *                                          user->mother (is a link to another user..)
     *
     *           optional 'useWhereAsOn' bool   default false;
     *                                          convert the where argments from the object being added
     *                                          into ON arguments.
     *
     *
     * @return error|none
     * @access   public
     * @author   Stijn de Reede      
     */
    public function joinAdd($obj = false, $joinType = 'INNER', $joinAs = false, $joinCol = false)
    {
        global $_DB_DATAOBJECT;
        if ($obj === false) {
            $this->_join = '';
            return null;
        }

        //echo '
'; print_r(func_get_args());
        $useWhereAsOn = false;
        // support for 2nd argument as an array of options
        if (is_array($joinType)) {
            // new options can now go in here... (dont forget to document them)
            $useWhereAsOn = !empty($joinType['useWhereAsOn']);
            $joinCol = isset($joinType['joinCol']) ? $joinType['joinCol'] : $joinCol;
            $joinAs = isset($joinType['joinAs']) ? $joinType['joinAs'] : $joinAs;
            $joinType = isset($joinType['joinType']) ? $joinType['joinType'] : 'INNER';
        }
        // support for array as first argument
        // this assumes that you dont have a links.ini for the specified table.
        // and it doesnt exist as am extended dataobject!! - experimental.

        $ofield = false; // object field
        $tfield = false; // this field
        $toTable = false;
        if (is_array($obj)) {
            $tfield = $obj[0];

            if (count($obj) == 3) {
                $ofield = $obj[2];
                $obj = $obj[1];
            } else {
                list($toTable, $ofield) = explode(':', $obj[1]);

                $obj = is_string($toTable) ? DB_DataObject::factory($toTable) : $toTable;

                if (!$obj || !is_object($obj) || is_a($obj, 'PEAR_Error')) {
                    $obj = new DB_DataObject;
                    $obj->__table = $toTable;
                }
                $obj->_connect();
            }
            // set the table items to nothing.. - eg. do not try and match
            // things in the child table...???
            $items = array();
        }

        if (!is_object($obj) || !is_a($obj, 'DB_DataObject')) {
            return $this->raiseError("joinAdd: called without an object", DB_DATAOBJECT_ERROR_NODATA, PEAR_ERROR_DIE);
        }
        /*  make sure $this->_database is set.  */
        $this->_connect();
        $DB = $_DB_DATAOBJECT['CONNECTIONS'][$this->_database_dsn_md5];


        /// CHANGED 26 JUN 2009 - we prefer links from our local table over the remote one.

        /* otherwise see if there are any links from this table to the obj. */
        //print_r($this->links());
        if (($ofield === false) && ($links = $this->links())) {
            // this enables for support for arrays of links in ini file.
            // link contains this_column[] =  linked_table:linked_column
            // or standard way.
            // link contains this_column =  linked_table:linked_column
            foreach ($links as $k => $linkVar) {
                if (!is_array($linkVar)) {
                    $linkVar = array($linkVar);
                }
                foreach ($linkVar as $v) {


                    /* link contains {this column} = {linked table}:{linked column} */
                    $ar = explode(':', $v);
                    // Feature Request #4266 - Allow joins with multiple keys
                    if (strpos($k, ',') !== false) {
                        $k = explode(',', $k);
                    }
                    if (strpos($ar[1], ',') !== false) {
                        $ar[1] = explode(',', $ar[1]);
                    }

                    if ($ar[0] != $obj->tableName()) {
                        continue;
                    }
                    if ($joinCol !== false) {
                        if ($k == $joinCol) {
                            // got it!?
                            $tfield = $k;
                            $ofield = $ar[1];
                            break;
                        }
                        continue;
                    }
                    $tfield = $k;
                    $ofield = $ar[1];
                    break;
                }
            }
        }
        /* look up the links for obj table */
        //print_r($obj->links());
        if (!$ofield && ($olinks = $obj->links())) {
            foreach ($olinks as $k => $linkVar) {
                /* link contains {this column} = array ( {linked table}:{linked column} )*/
                if (!is_array($linkVar)) {
                    $linkVar = array($linkVar);
                }
                foreach ($linkVar as $v) {

                    /* link contains {this column} = {linked table}:{linked column} */
                    $ar = explode(':', $v);

                    // Feature Request #4266 - Allow joins with multiple keys
                    $links_key_array = strpos($k, ',');
                    if ($links_key_array !== false) {
                        $k = explode(',', $k);
                    }

                    $ar_array = strpos($ar[1], ',');
                    if ($ar_array !== false) {
                        $ar[1] = explode(',', $ar[1]);
                    }

                    if ($ar[0] != $this->tableName()) {
                        continue;
                    }

                    // you have explictly specified the column
                    // and the col is listed here..
                    // not sure if 1:1 table could cause probs here..

                    if ($joinCol !== false) {
                        $this->raiseError(
                            "joinAdd: You cannot target a join column in the " .
                            "'link from' table ({$obj->tableName()}). " .
                            "Either remove the fourth argument to joinAdd() " .
                            "({$joinCol}), or alter your links.ini file.",
                            DB_DATAOBJECT_ERROR_NODATA
                        );
                        return false;
                    }

                    $ofield = $k;
                    $tfield = $ar[1];
                    break;
                }
            }
        }

        // finally if these two table have column names that match do a join by default on them

        if (($ofield === false) && $joinCol) {
            $ofield = $joinCol;
            $tfield = $joinCol;
        }
        /* did I find a conneciton between them? */

        if ($ofield === false) {
            $this->raiseError(
                "joinAdd: {$obj->tableName()} has no link with {$this->tableName()}",
                DB_DATAOBJECT_ERROR_NODATA
            );
            return false;
        }
        $joinType = strtoupper($joinType);

        // we default to joining as the same name (this is remvoed later..)

        if ($joinAs === false) {
            $joinAs = $obj->tableName();
        }

        $quoteIdentifiers = !empty($_DB_DATAOBJECT['CONFIG']['quote_identifiers']);
        $options = $_DB_DATAOBJECT['CONFIG'];

        // not sure  how portable adding database prefixes is..
        $objTable = $quoteIdentifiers ?
            $DB->quoteIdentifier($obj->tableName()) :
            $obj->tableName();

        $dbPrefix = '';
        if (strlen($obj->_database) && in_array($DB->dsn['phptype'], array('mysql', 'mysqli'))) {
            $dbPrefix = ($quoteIdentifiers
                    ? $DB->quoteIdentifier($obj->_database)
                    : $obj->_database) . '.';
        }

        // if they are the same, then dont add a prefix...
        if ($obj->_database == $this->_database) {
            $dbPrefix = '';
        }
        // as far as we know only mysql supports database prefixes..
        // prefixing the database name is now the default behaviour,
        // as it enables joining mutiple columns from multiple databases...

        // prefix database (quoted if neccessary..)
        $objTable = $dbPrefix . $objTable;

        $cond = '';

        // if obj only a dataobject - eg. no extended class has been defined..
        // it obvioulsy cant work out what child elements might exist...
        // until we get on the fly querying of tables..
        // note: we have already checked that it is_a(db_dataobject earlier)
        if (strtolower(get_class($obj)) != 'db_dataobject') {

            // now add where conditions for anything that is set in the object


            $items = $obj->table();
            // will return an array if no items..

            // only fail if we where expecting it to work (eg. not joined on a array)

            if (!$items) {
                $this->raiseError(
                    "joinAdd: No table definition for {$obj->tableName()}",
                    DB_DATAOBJECT_ERROR_INVALIDCONFIG
                );
                return false;
            }

            $ignore_null = !isset($options['disable_null_strings'])
                || !is_string($options['disable_null_strings'])
                || strtolower($options['disable_null_strings']) !== 'full';


            foreach ($items as $k => $v) {
                if (!isset($obj->$k) && $ignore_null) {
                    continue;
                }

                $kSql = ($quoteIdentifiers ? $DB->quoteIdentifier($k) : $k);

                if (DB_DataObject::_is_null($obj, $k)) {
                    $obj->whereAdd("{$joinAs}.{$kSql} IS NULL");
                    continue;
                }

                if ($v & DB_DATAOBJECT_STR) {
                    $obj->whereAdd("{$joinAs}.{$kSql} = " . $this->_quote((string)(
                        ($v & DB_DATAOBJECT_BOOL) ?
                            // this is thanks to the braindead idea of postgres to
                            // use t/f for boolean.
                            (($obj->$k === 'f') ? 0 : (int)(bool)$obj->$k) :
                            $obj->$k
                        )));
                    continue;
                }
                if (is_numeric($obj->$k)) {
                    $obj->whereAdd("{$joinAs}.{$kSql} = {$obj->$k}");
                    continue;
                }

                if (is_object($obj->$k) && is_a($obj->$k, 'DB_DataObject_Cast')) {
                    $value = $obj->$k->toString($v, $DB);
                    if ((new PEAR)->isError($value)) {
                        $this->raiseError($value->getMessage(), DB_DATAOBJECT_ERROR_INVALIDARG);
                        return false;
                    }
                    $obj->whereAdd("{$joinAs}.{$kSql} = $value");
                    continue;
                }


                /* this is probably an error condition! */
                $obj->whereAdd("{$joinAs}.{$kSql} = 0");
            }
            if ($this->_query === false) {
                $this->raiseError(
                    "joinAdd can not be run from a object that has had a query run on it,
                    clone the object or create a new one and use setFrom()",
                    DB_DATAOBJECT_ERROR_INVALIDARGS
                );
                return false;
            }
        }

        // and finally merge the whereAdd from the child..
        if ($obj->_query['condition']) {
            $cond = preg_replace('/^\sWHERE/i', '', $obj->_query['condition']);

            if (!$useWhereAsOn) {
                $this->whereAdd($cond);
            }
        }


        // nested (join of joined objects..)
        $appendJoin = '';
        if ($obj->_join) {
            // postgres allows nested queries, with ()'s
            // not sure what the results are with other databases..
            // may be unpredictable..
            if (in_array($DB->dsn["phptype"], array('pgsql'))) {
                $objTable = "($objTable {$obj->_join})";
            } else {
                $appendJoin = $obj->_join;
            }
        }


        // fix for #2216
        // add the joinee object's conditions to the ON clause instead of the WHERE clause
        if ($useWhereAsOn && strlen($cond)) {
            $appendJoin = ' AND ' . $cond . ' ' . $appendJoin;
        }


        $table = $this->tableName();

        if ($quoteIdentifiers) {
            $joinAs = $DB->quoteIdentifier($joinAs);
            $table = $DB->quoteIdentifier($table);
            $ofield = (is_array($ofield)) ? array_map(array($DB, 'quoteIdentifier'), $ofield) : $DB->quoteIdentifier($ofield);
            $tfield = (is_array($tfield)) ? array_map(array($DB, 'quoteIdentifier'), $tfield) : $DB->quoteIdentifier($tfield);
        }
        // add database prefix if they are different databases


        $fullJoinAs = '';
        $addJoinAs = ($quoteIdentifiers ? $DB->quoteIdentifier($obj->tableName()) : $obj->tableName()) != $joinAs;
        if ($addJoinAs) {
            // join table a AS b - is only supported by a few databases and is probably not needed
            // , however since it makes the whole Statement alot clearer we are leaving it in
            // for those databases.
            $fullJoinAs = in_array($DB->dsn["phptype"], array('mysql', 'mysqli', 'pgsql')) ? "AS {$joinAs}" : $joinAs;
        } else {
            // if
            $joinAs = $dbPrefix . $joinAs;
        }


        switch ($joinType) {
            case 'INNER':
            case 'LEFT':
            case 'RIGHT': // others??? .. cross, left outer, right outer, natural..?

                // Feature Request #4266 - Allow joins with multiple keys
                $jadd = "\n {$joinType} JOIN {$objTable} {$fullJoinAs}";
                //$this->_join .= "\n {$joinType} JOIN {$objTable} {$fullJoinAs}";
                if (is_array($ofield)) {
                    $key_count = count($ofield);
                    for ($i = 0; $i < $key_count; $i++) {
                        if ($i == 0) {
                            $jadd .= " ON ({$joinAs}.{$ofield[$i]}={$table}.{$tfield[$i]}) ";
                        } else {
                            $jadd .= " AND {$joinAs}.{$ofield[$i]}={$table}.{$tfield[$i]} ";
                        }
                    }
                    $jadd .= ' ' . $appendJoin . ' ';
                } else {
                    $jadd .= " ON ({$joinAs}.{$ofield}={$table}.{$tfield}) {$appendJoin} ";
                }
                // jadd avaliable for debugging join build.
                //echo $jadd ."\n";
                $this->_join .= $jadd;
                break;

            case '': // this is just a standard multitable select..
                $this->_join .= "\n , {$objTable} {$fullJoinAs} {$appendJoin}";
                $this->whereAdd("{$joinAs}.{$ofield}={$table}.{$tfield}");
        }


        return true;
    }

    /**
     * Adds multiple Columns or objects to select with formating.
     *
     * $object->selectAs(null); // adds "table.colnameA as colnameA,table.colnameB as colnameB,......"
     *                      // note with null it will also clear the '*' default select
     * $object->selectAs(array('a','b'),'%s_x'); // adds "a as a_x, b as b_x"
     * $object->selectAs(array('a','b'),'ddd_%s','ccc'); // adds "ccc.a as ddd_a, ccc.b as ddd_b"
     * $object->selectAdd($object,'prefix_%s'); // calls $object->get_table and adds it all as
     *                  objectTableName.colnameA as prefix_colnameA
     *
     * @param array|object|null the array or object to take column names from.
     * @param string $format
     * @param bool $tableName
     * @return bool|void
     * @access public
     */
    public function selectAs($from = null, $format = '%s', $tableName = false)
    {
        global $_DB_DATAOBJECT;

        if ($this->_query === false) {
            $this->raiseError(
                "You cannot do two queries on the same object (copy it before finding)",
                DB_DATAOBJECT_ERROR_INVALIDARGS
            );
            return false;
        }

        if ($from === null) {
            // blank the '*'
            $this->selectAdd();
            $from = $this;
        }


        $table = $this->tableName();
        if (is_object($from)) {
            $table = $from->tableName();
            $from = array_keys($from->table());
        }

        if ($tableName !== false) {
            $table = $tableName;
        }
        $s = '%s';
        if (!empty($_DB_DATAOBJECT['CONFIG']['quote_identifiers'])) {
            $this->_connect();
            $DB = $_DB_DATAOBJECT['CONNECTIONS'][$this->_database_dsn_md5];
            $s = $DB->quoteIdentifier($s);
            $format = $DB->quoteIdentifier($format);
        }
        foreach ($from as $k) {
            $this->selectAdd(sprintf("{$s}.{$s} as {$format}", $table, $k, $k));
        }
        $this->_query['data_select'] .= "\n";
    }

    /**
     * Factory method for calling DB_DataObject_Cast
     *
     * if used with 1 argument DB_DataObject_Cast::sql($value) is called
     *
     * if used with 2 arguments DB_DataObject_Cast::$value($callvalue) is called
     * valid first arguments are: blob, string, date, sql
     *
     * eg. $member->updated = $member->sqlValue('NOW()');
     *
     *
     * might handle more arguments for escaping later...
     *
     *
     * @param string $value (or type if used with 2 arguments)
     * @return mixed
     */

    public function sqlValue($value)
    {
        $method = 'sql';
        if (func_num_args() == 2) {
            $method = $value;
            $value = func_get_arg(1);
        }
        require_once 'DB/DataObject/Cast.php';
        return call_user_func(array('DB_DataObject_Cast', $method), $value);
    }


    /* ----------------------- Debugger ------------------ */

    /**
     * Copies items that are in the table definitions from an
     * array or object into the current object
     * will not override key values.
     *
     *
     * @param array | object $from
     * @param string $format eg. map xxxx_name to $object->name using 'xxxx_%s' (defaults to %s - eg. name -> $object->name
     * @param boolean $skipEmpty (dont assign empty values if a column is empty (eg. '' / 0 etc...)
     * @access   public
     * @return array|true
     */
    public function setFrom($from, $format = '%s', $skipEmpty = false)
    {
        global $_DB_DATAOBJECT;
        $keys = $this->keys();
        $items = $this->table();

        if (!$items) {
            $this->raiseError(
                "setFrom:Could not find table definition for {$this->tableName()}",
                DB_DATAOBJECT_ERROR_INVALIDCONFIG
            );
            return null;
        }
        $overload_return = array();
        foreach (array_keys($items) as $k) {
            if (in_array($k, $keys)) {
                continue; // dont overwrite keys
            }
            if (!$k) {
                continue; // ignore empty keys!!! what
            }

            $chk = is_object($from) &&
                (
                version_compare(phpversion(), "5.1.0", ">=") ?
                    property_exists($from, sprintf($format, $k)) :  // php5.1
                    array_key_exists(sprintf($format, $k), get_class_vars($from)) //older
                );
            // if from has property ($format($k)
            if ($chk) {
                $kk = (strtolower($k) == 'from') ? '_from' : $k;
                if (method_exists($this, 'set' . $kk)) {
                    $ret = $this->{'set' . $kk}($from->{sprintf($format, $k)});
                    if (is_string($ret)) {
                        $overload_return[$k] = $ret;
                    }
                    continue;
                }
                $this->$k = $from->{sprintf($format, $k)};
                continue;
            }

            if (is_object($from)) {
                continue;
            }

            if (empty($from[sprintf($format, $k)]) && $skipEmpty) {
                continue;
            }

            if (!isset($from[sprintf($format, $k)]) && !DB_DataObject::_is_null($from, sprintf($format, $k))) {
                continue;
            }

            $kk = (strtolower($k) == 'from') ? '_from' : $k;
            if (method_exists($this, 'set' . $kk)) {
                $ret = $this->{'set' . $kk}($from[sprintf($format, $k)]);
                if (is_string($ret)) {
                    $overload_return[$k] = $ret;
                }
                continue;
            }
            $val = $from[sprintf($format, $k)];
            if (is_a($val, 'DB_DataObject_Cast')) {
                $this->$k = $val;
                continue;
            }
            if (is_object($val) || is_array($val)) {
                continue;
            }
            $ret = $this->fromValue($k, $val);
            if ($ret !== true) {
                $overload_return[$k] = 'Not A Valid Value';
            }
            //$this->$k = $from[sprintf($format,$k)];
        }
        if ($overload_return) {
            return $overload_return;
        }
        return true;
    }

    /**
     * standard set* implementation.
     *
     * takes data and uses it to set dates/strings etc.
     * normally called from __call..
     *
     * Current supports
     *   date      = using (standard time format, or unixtimestamp).... so you could create a method :
     *               function setLastread($string) { $this->fromValue('lastread',strtotime($string)); }
     *
     *   time      = using strtotime
     *   datetime  = using  same as date - accepts iso standard or unixtimestamp.
     *   string    = typecast only..
     *
     * TODO: add formater:: eg. d/m/Y for date! ???
     *
     * @param string       column of database
     * @param mixed        value to assign
     *
     * @return   true| false     (False on error)
     * @access   public
     * @see      DB_DataObject::_call
     */


    public function fromValue($col, $value)
    {
        global $_DB_DATAOBJECT;
        $options = $_DB_DATAOBJECT['CONFIG'];
        $cols = $this->table();
        // dont know anything about this col..
        if (!isset($cols[$col]) || is_a($value, 'DB_DataObject_Cast')) {
            $this->$col = $value;
            return true;
        }
        //echo "FROM VALUE $col, {$cols[$col]}, $value\n";
        switch (true) {
            // set to null and column is can be null...
            case ((!($cols[$col] & DB_DATAOBJECT_NOTNULL)) && DB_DataObject::_is_null($value, false)):
            case (is_object($value) && is_a($value, 'DB_DataObject_Cast')):
                $this->$col = $value;
                return true;

            // fail on setting null on a not null field..
            case (($cols[$col] & DB_DATAOBJECT_NOTNULL) && DB_DataObject::_is_null($value, false)):

                return false;

            case (($cols[$col] & DB_DATAOBJECT_DATE) && ($cols[$col] & DB_DATAOBJECT_TIME)):
                // empty values get set to '' (which is inserted/updated as NULl
                if (!$value) {
                    $this->$col = '';
                }

                if (is_numeric($value)) {
                    $this->$col = date('Y-m-d H:i:s', $value);
                    return true;
                }

                // eak... - no way to validate date time otherwise...
                $this->$col = (string)$value;
                return true;

            case ($cols[$col] & DB_DATAOBJECT_DATE):
                // empty values get set to '' (which is inserted/updated as NULl

                if (!$value) {
                    $this->$col = '';
                    return true;
                }

                if (is_numeric($value)) {
                    $this->$col = date('Y-m-d', $value);
                    return true;
                }

                // try date!!!!
                require_once 'Date.php';
                $x = new Date($value);
                $this->$col = $x->format("%Y-%m-%d");
                return true;

            case ($cols[$col] & DB_DATAOBJECT_TIME):
                // empty values get set to '' (which is inserted/updated as NULl
                if (!$value) {
                    $this->$col = '';
                }

                $guess = strtotime($value);
                if ($guess != -1) {
                    $this->$col = date('H:i:s', $guess);
                    return $return = true;
                }
                // otherwise an error in type...
                return false;

            case ($cols[$col] & DB_DATAOBJECT_STR):

                $this->$col = (string)$value;
                return true;

            // todo : floats numerics and ints...
            default:
                $this->$col = $value;
                return true;
        }
    }

    /**
     * Returns an associative array from the current data
     * (kind of oblivates the idea behind DataObjects, but
     * is usefull if you use it with things like QuickForms.
     *
     * you can use the format to return things like user[key]
     * by sending it $object->toArray('user[%s]')
     *
     * will also return links converted to arrays.
     *
     * @param string  sprintf format for array
     * @param bool||number    [true = elemnts that have a value set],
     *                          [false = table + returned colums] ,
     *                          [0 = returned columsn only]
     *
     * @access   public
     * @return   array of key => value for row
     */

    public function toArray($format = '%s', $hideEmpty = false)
    {
        global $_DB_DATAOBJECT;

        // we use false to ignore sprintf.. (speed up..)
        $format = $format == '%s' ? false : $format;

        $ret = array();
        $rf = ($this->_resultFields !== false) ? $this->_resultFields :
            (isset($_DB_DATAOBJECT['RESULTFIELDS'][$this->_DB_resultid]) ?
                $_DB_DATAOBJECT['RESULTFIELDS'][$this->_DB_resultid] : false);

        $ar = ($rf !== false) ?
            (($hideEmpty === 0) ? $rf : array_merge($rf, $this->table())) :
            $this->table();

        foreach ($ar as $k => $v) {
            if (!isset($this->$k)) {
                if (!$hideEmpty) {
                    $ret[$format === false ? $k : sprintf($format, $k)] = '';
                }
                continue;
            }
            // call the overloaded getXXXX() method. - except getLink and getLinks
            if (method_exists($this, 'get' . $k) && !in_array(strtolower($k), array('links', 'link'))) {
                $ret[$format === false ? $k : sprintf($format, $k)] = $this->{'get' . $k}();
                continue;
            }
            // should this call toValue() ???
            $ret[$format === false ? $k : sprintf($format, $k)] = $this->$k;
        }
        if (!$this->_link_loaded) {
            return $ret;
        }
        foreach ($this->_link_loaded as $k) {
            $ret[$format === false ? $k : sprintf($format, $k)] = $this->$k->toArray();
        }

        return $ret;
    }

    /**
     * validate the values of the object (usually prior to inserting/updating..)
     *
     * Note: This was always intended as a simple validation routine.
     * It lacks understanding of field length, whether you are inserting or updating (and hence null key values)
     *
     * This should be moved to another class: DB_DataObject_Validate
     *      FEEL FREE TO SEND ME YOUR VERSION FOR CONSIDERATION!!!
     *
     * Usage:
     * if (is_array($ret = $obj->validate())) { ... there are problems with the data ... }
     *
     * Logic:
     *   - defaults to only testing strings/numbers if numbers or strings are the correct type and null values are correct
     *   - validate Column methods : "validate{ROWNAME}()"  are called if they are defined.
     *            These methods should return
     *                  true = everything ok
     *                  false|object = something is wrong!
     *
     *   - This method loads and uses the PEAR Validate Class.
     *
     *
     * @access  public
     * @return array|bool
     */
    public function validate()
    {
        global $_DB_DATAOBJECT;
        require_once 'Validate.php';
        $table = $this->table();
        $ret = array();
        $seq = $this->sequenceKey();
        $options = $_DB_DATAOBJECT['CONFIG'];
        foreach ($table as $key => $val) {


            // call user defined validation always...
            $method = "Validate" . ucfirst($key);
            if (method_exists($this, $method)) {
                $ret[$key] = $this->$method();
                continue;
            }

            // if not null - and it's not set.......

            if ($val & DB_DATAOBJECT_NOTNULL && DB_DataObject::_is_null($this, $key)) {
                // dont check empty sequence key values..
                if (($key == $seq[0]) && ($seq[1] == true)) {
                    continue;
                }
                $ret[$key] = false;
                continue;
            }


            if (DB_DataObject::_is_null($this, $key)) {
                if ($val & DB_DATAOBJECT_NOTNULL) {
                    $this->debug("'null' field used for '$key', but it is defined as NOT NULL", 'VALIDATION', 4);
                    $ret[$key] = false;
                    continue;
                }
                continue;
            }

            // ignore things that are not set. ?

            if (!isset($this->$key)) {
                continue;
            }

            // if the string is empty.. assume it is ok..
            if (!is_object($this->$key) && !is_array($this->$key) && !strlen((string)$this->$key)) {
                continue;
            }

            // dont try and validate cast objects - assume they are problably ok..
            if (is_object($this->$key) && is_a($this->$key, 'DB_DataObject_Cast')) {
                continue;
            }
            // at this point if you have set something to an object, and it's not expected
            // the Validate will probably break!!... - rightly so! (your design is broken,
            // so issuing a runtime error like PEAR_Error is probably not appropriate..

            switch (true) {
                // todo: date time.....
                case  ($val & DB_DATAOBJECT_STR):
                    $ret[$key] = (new Validate)->string($this->$key, VALIDATE_PUNCTUATION . VALIDATE_NAME);
                    break;
                case  ($val & DB_DATAOBJECT_INT):
                    $ret[$key] = (new Validate)->number($this->$key, array('decimal' => '.'));
                    break;
            }
        }
        // if any of the results are false or an object (eg. PEAR_Error).. then return the array..
        foreach ($ret as $key => $val) {
            if ($val !== true) {
                return $ret;
            }
        }
        return true; // everything is OK.
    }

    /**
     * Gets the DB object related to an object - so you can use funky peardb stuf with it :)
     *
     * @access public
     * @return bool|object
     */
    public function getDatabaseConnection()
    {
        global $_DB_DATAOBJECT;

        if (($e = $this->_connect()) !== true) {
            return $e;
        }
        if (!isset($_DB_DATAOBJECT['CONNECTIONS'][$this->_database_dsn_md5])) {
            $r = false;
            return $r;
        }
        return $_DB_DATAOBJECT['CONNECTIONS'][$this->_database_dsn_md5];
    }

    /**
     * Gets the DB result object related to the objects active query
     *  - so you can use funky pear stuff with it - like pager for example.. :)
     *
     * @access public
     * @return bool|object
     */

    public function getDatabaseResult()
    {
        global $_DB_DATAOBJECT;
        $this->_connect();
        if (!isset($_DB_DATAOBJECT['RESULTS'][$this->_DB_resultid])) {
            $r = false;
            return $r;
        }
        return $_DB_DATAOBJECT['RESULTS'][$this->_DB_resultid];
    }

    /**
     * Overload Extension support
     *  - enables setCOLNAME/getCOLNAME
     *  if you define a set/get method for the item it will be called.
     * otherwise it will just return/set the value.
     * NOTE this currently means that a few Names are NO-NO's
     * eg. links,link,linksarray, from, Databaseconnection,databaseresult
     *
     * note
     *  - set is automatically called by setFrom.
     *   - get is automatically called by toArray()
     *
     * setters return true on success. = strings on failure
     * getters return the value!
     *
     * this fires off trigger_error - if any problems.. pear_error,
     * has problems with 4.3.2RC2 here
     *
     * @access public
     * @param $method
     * @param $params
     * @param $return
     * @return true?
     * @throws ReflectionException
     * @see overload
     */


    public function _call($method, $params, &$return)
    {

        //$this->debug("ATTEMPTING OVERLOAD? $method");
        // ignore constructors : - mm
        if (strtolower($method) == strtolower(get_class($this))) {
            return true;
        }
        $type = strtolower(substr($method, 0, 3));
        $class = get_class($this);
        if (($type != 'set') && ($type != 'get')) {
            return false;
        }


        // deal with naming conflick of setFrom = this is messy ATM!

        if (strtolower($method) == 'set_from') {
            $return = $this->toValue('from', isset($params[0]) ? $params[0] : null);
            return true;
        }

        $element = substr($method, 3);

        // dont you just love php's case insensitivity!!!!

        $array = array_keys(get_class_vars($class));
        /* php5 version which segfaults on 5.0.3 */
        if (class_exists('ReflectionClass')) {
            $reflection = new ReflectionClass($class);
            $array = array_keys($reflection->getdefaultProperties());
        }

        if (!in_array($element, $array)) {
            // munge case
            foreach ($array as $k) {
                $case[strtolower($k)] = $k;
            }
            if ((substr(phpversion(), 0, 1) == 5) && isset($case[strtolower($element)])) {
                trigger_error("PHP5 set/get calls should match the case of the variable", E_USER_WARNING);
                $element = strtolower($element);
            }

            // does it really exist?
            if (!isset($case[$element])) {
                return false;
            }
            // use the mundged case
            $element = $case[$element]; // real case !
        }


        if ($type == 'get') {
            $return = $this->toValue($element, isset($params[0]) ? $params[0] : null);
            return true;
        }


        $return = $this->fromValue($element, $params[0]);

        return true;
    }

    /**
     * standard get* implementation.
     *
     *  with formaters..
     * supported formaters:
     *   date/time : %d/%m/%Y (eg. php strftime) or pear::Date
     *   numbers   : %02d (eg. sprintf)
     *  NOTE you will get unexpected results with times like 0000-00-00 !!!
     *
     *
     *
     * @param string       column of database
     * @param format       foramt
     *
     * @return string|true
     * @access   public
     * @see      DB_DataObject::_call(),strftime(),Date::format()
     */
    public function toValue($col, $format = null)
    {
        if (is_null($format)) {
            return $this->$col;
        }
        $cols = $this->table();
        switch (true) {
            case (($cols[$col] & DB_DATAOBJECT_DATE) && ($cols[$col] & DB_DATAOBJECT_TIME)):
                if (!$this->$col) {
                    return '';
                }
                $guess = strtotime($this->$col);
                if ($guess != -1) {
                    return strftime($format, $guess);
                }
                // eak... - no way to validate date time otherwise...
                return $this->$col;
            case ($cols[$col] & DB_DATAOBJECT_DATE):
                if (!$this->$col) {
                    return '';
                }
                $guess = strtotime($this->$col);
                if ($guess != -1) {
                    return strftime($format, $guess);
                }
                // try date!!!!
                require_once 'Date.php';
                $x = new Date($this->$col);
                return $x->format($format);

            case ($cols[$col] & DB_DATAOBJECT_TIME):
                if (!$this->$col) {
                    return '';
                }
                $guess = strtotime($this->$col);
                if ($guess > -1) {
                    return strftime($format, $guess);
                }
                // otherwise an error in type...
                return $this->$col;

            case ($cols[$col] & DB_DATAOBJECT_MYSQLTIMESTAMP):
                if (!$this->$col) {
                    return '';
                }
                require_once 'Date.php';

                $x = new Date($this->$col);

                return $x->format($format);


            case ($cols[$col] & DB_DATAOBJECT_BOOL):

                if ($cols[$col] & DB_DATAOBJECT_STR) {
                    // it's a 't'/'f' !
                    return ($this->$col === 't');
                }
                return (bool)$this->$col;


            default:
                return sprintf($format, $this->col);
        }
    }

    /**
     * autoload Class relating to a table
     * (deprecited - use ::factory)
     *
     * @param string $table table
     * @access private
     * @return string classname on Success
     */
    public function staticAutoloadTable($table)
    {
        global $_DB_DATAOBJECT;
        if (empty($_DB_DATAOBJECT['CONFIG'])) {
            DB_DataObject::_loadConfig();
        }
        $p = isset($_DB_DATAOBJECT['CONFIG']['class_prefix']) ?
            $_DB_DATAOBJECT['CONFIG']['class_prefix'] : '';
        $class = $p . preg_replace('/[^A-Z0-9]/i', '_', ucfirst($table));

        $ce = substr(phpversion(), 0, 1) > 4 ? class_exists($class, false) : class_exists($class);
        $class = $ce ? $class : DB_DataObject::_autoloadClass($class);
        return $class;
    }

    /* ---- LEGACY BC METHODS - NOT DOCUMENTED - See Documentation on New Methods. ---*/

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

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

// technically 4.3.2RC1 was broken!!
// looks like 4.3.3 may have problems too....
if (!defined('DB_DATAOBJECT_NO_OVERLOAD')) {
    if ((phpversion() != '4.3.2-RC1') && (version_compare(phpversion(), "4.3.1") > 0)) {
        if (version_compare(phpversion(), "5") < 0) {
            overload('DB_DataObject');
        }
        $GLOBALS['_DB_DATAOBJECT']['OVERLOADED'] = true;
    }
}