The API

• 1.2.0.7296 RC2
• 1.2 Tests
• 1.1.19.6971

• About CakePHP
• Donate

• CakePHP
• API
• Docs
• Bakery
• Live
• Forge
• Trac

dbo_source.php

Go to the documentation of this file.

<?php
/* SVN FILE: $Id: dbo__source_8php-source.html 580 2008-07-01 14:45:49Z gwoo $ */
/**
 * Short description for file.
 *
 * Long description for file
 *
 * PHP versions 4 and 5
 *
 * CakePHP(tm) :  Rapid Development Framework <http://www.cakephp.org/>
 * Copyright 2005-2008, Cake Software Foundation, Inc.
 *                              1785 E. Sahara Avenue, Suite 490-204
 *                              Las Vegas, Nevada 89104
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @filesource
 * @copyright       Copyright 2005-2008, Cake Software Foundation, Inc.
 * @link                http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project
 * @package         cake
 * @subpackage      cake.cake.libs.model.datasources
 * @since           CakePHP(tm) v 0.10.0.1076
 * @version         $Revision: 580 $
 * @modifiedby      $LastChangedBy: gwoo $
 * @lastmodified    $Date: 2008-07-01 09:45:49 -0500 (Tue, 01 Jul 2008) $
 * @license         http://www.opensource.org/licenses/mit-license.php The MIT License
 */
App::import('Core', 'Set');

/**
 * DboSource
 *
 * Creates DBO-descendant objects from a given db connection configuration
 *
 * @package     cake
 * @subpackage  cake.cake.libs.model.datasources
 */
class DboSource extends DataSource {
/**
 * Description string for this Database Data Source.
 *
 * @var unknown_type
 */
    var $description = "Database Data Source";
/**
 * index definition, standard cake, primary, index, unique
 *
 * @var array
 */
    var $index = array('PRI' => 'primary', 'MUL' => 'index', 'UNI' => 'unique');
/**
 * Enter description here...
 *
 * @var unknown_type
 */
    var $startQuote = null;
/**
 * Enter description here...
 *
 * @var unknown_type
 */
    var $endQuote = null;
/**
 * Enter description here...
 *
 * @var unknown_type
 */
    var $alias = 'AS ';
/**
 * Caches fields quoted in DboSource::name()
 *
 * @var array
 */
    var $fieldCache = array();
/**
 * Enter description here...
 *
 * @var unknown_type
 */
    var $__bypass = false;
/**
 * The set of valid SQL operations usable in a WHERE statement
 *
 * @var array
 */
    var $__sqlOps = array('like', 'ilike', 'or', 'not', 'in', 'between', 'regexp', 'similar to');
/**
 * Index of basic SQL commands
 *
 * @var array
 * @access protected
 */
    var $_commands = array(
        'begin'    => 'BEGIN',
        'commit'   => 'COMMIT',
        'rollback' => 'ROLLBACK'
    );
/**
 * Constructor
 */
    function __construct($config = null, $autoConnect = true) {
        if (!isset($config['prefix'])) {
            $config['prefix'] = '';
        }
        parent::__construct($config);
        $this->fullDebug = Configure::read() > 1;

        if ($autoConnect) {
            return $this->connect();
        } else {
            return true;
        }
    }
/**
 * Reconnects to database server with optional new settings
 *
 * @param array $config An array defining the new configuration settings
 * @return boolean True on success, false on failure
 */
    function reconnect($config = null) {
        $this->disconnect();
        if ($config != null) {
            $this->config = array_merge($this->_baseConfig, $config);
        }
        return $this->connect();
    }
/**
 * Prepares a value, or an array of values for database queries by quoting and escaping them.
 *
 * @param mixed $data A value or an array of values to prepare.
 * @return mixed Prepared value or array of values.
 */
    function value($data, $column = null) {
        if (is_array($data) && !empty($data)) {
            return array_map(array(&$this, 'value'), $data, array_fill(0, count($data), $column));
        } elseif (is_object($data)) {
            if (isset($data->type) && $data->type == 'identifier') {
                return $this->name($data->value);
            }
        } elseif (in_array($data, array('{$__cakeID__$}', '{$__cakeForeignKey__$}'), true)) {
            return $data;
        } else {
            return null;
        }
    }
/**
 * Returns an object to represent a database identifier in a query
 *
 * @param string $identifier
 * @return object An object representing a database identifier to be used in a query
 */
    function identifier($identifier) {
        $obj = new stdClass();
        $obj->type = 'identifier';
        $obj->value = $identifier;
        return $obj;
    }
/**
 * Returns an object to represent a database expression in a query
 *
 * @param string $expression
 * @return object An object representing a database expression to be used in a query
 */
    function expression($expression) {
        $obj = new stdClass();
        $obj->type = 'expression';
        $obj->value = $expression;
        return $obj;
    }
/**
 * Executes given SQL statement.
 *
 * @param string $sql SQL statement
 * @return unknown
 */
    function rawQuery($sql) {
        $this->took = $this->error = $this->numRows = false;
        return $this->execute($sql);
    }
/**
 * Queries the database with given SQL statement, and obtains some metadata about the result
 * (rows affected, timing, any errors, number of rows in resultset). The query is also logged.
 * If DEBUG is set, the log is shown all the time, else it is only shown on errors.
 *
 * @param string $sql
 * @return mixed Resource or object representing the result set, or false on failure
 */
    function execute($sql) {
        $t = getMicrotime();
        $this->_result = $this->_execute($sql);
        $this->took = round((getMicrotime() - $t) * 1000, 0);
        $this->affected = $this->lastAffected();
        $this->error = $this->lastError();
        $this->numRows = $this->lastNumRows();

        if (Configure::read() > 1) {
            $this->logQuery($sql);
        }

        if ($this->error) {
            $this->showQuery($sql);
            return false;
        } else {
            return $this->_result;
        }
    }
/**
 * DataSource Query abstraction
 *
 * @return resource Result resource identifier
 */
    function query() {
        $args     = func_get_args();
        $fields   = null;
        $order    = null;
        $limit    = null;
        $page     = null;
        $recursive = null;

        if (count($args) == 1) {
            return $this->fetchAll($args[0]);

        } elseif (count($args) > 1 && (strpos(strtolower($args[0]), 'findby') === 0 || strpos(strtolower($args[0]), 'findallby') === 0)) {
            $params = $args[1];

            if (strpos(strtolower($args[0]), 'findby') === 0) {
                $all  = false;
                $field = Inflector::underscore(preg_replace('/findBy/i', '', $args[0]));
            } else {
                $all  = true;
                $field = Inflector::underscore(preg_replace('/findAllBy/i', '', $args[0]));
            }

            $or = (strpos($field, '_or_') !== false);
            if ($or) {
                $field = explode('_or_', $field);
            } else {
                $field = explode('_and_', $field);
            }
            $off = count($field) - 1;

            if (isset($params[1 + $off])) {
                $fields = $params[1 + $off];
            }

            if (isset($params[2 + $off])) {
                $order = $params[2 + $off];
            }

            if (!array_key_exists(0, $params)) {
                return false;
            }

            $c = 0;
            $query = array();
            foreach ($field as $f) {
                $query[$args[2]->alias . '.' . $f] = $params[$c];
                $c++;
            }

            if ($or) {
                $query = array('OR' => $query);
            }

            if ($all) {

                if (isset($params[3 + $off])) {
                    $limit = $params[3 + $off];
                }

                if (isset($params[4 + $off])) {
                    $page = $params[4 + $off];
                }

                if (isset($params[5 + $off])) {
                    $recursive = $params[5 + $off];
                }
                return $args[2]->findAll($query, $fields, $order, $limit, $page, $recursive);
            } else {
                if (isset($params[3 + $off])) {
                    $recursive = $params[3 + $off];
                }
                return $args[2]->find($query, $fields, $order, $recursive);
            }
        } else {
            if (isset($args[1]) && $args[1] === true) {
                return $this->fetchAll($args[0], true);
            } else if (isset($args[1]) && !is_array($args[1]) ) {
                return $this->fetchAll($args[0], false);
            } else if (isset($args[1]) && is_array($args[1])) {
                $offset = 0;
                if (isset($args[2])) {
                    $cache = $args[2];
                } else {
                    $cache = true;
                }
                $args[1] = array_map(array(&$this, 'value'), $args[1]);
                return $this->fetchAll(String::insert($args[0], $args[1]), $cache);
            }
        }
    }
/**
 * Returns a row from current resultset as an array
 *
 * @return array The fetched row as an array
 */
    function fetchRow($sql = null) {
        if (!empty($sql) && is_string($sql) && strlen($sql) > 5) {
            if (!$this->execute($sql)) {
                return null;
            }
        }

        if ($this->hasResult()) {
            $this->resultSet($this->_result);
            $resultRow = $this->fetchResult();
            return $resultRow;
        } else {
            return null;
        }
    }
/**
 * Returns an array of all result rows for a given SQL query.
 * Returns false if no rows matched.
 *
 * @param string $sql SQL statement
 * @param boolean $cache Enables returning/storing cached query results
 * @return array Array of resultset rows, or false if no rows matched
 */
    function fetchAll($sql, $cache = true, $modelName = null) {
        if ($cache && isset($this->_queryCache[$sql])) {
            if (preg_match('/^\s*select/i', $sql)) {
                return $this->_queryCache[$sql];
            }
        }

        if ($this->execute($sql)) {
            $out = array();

            $first = $this->fetchRow();
            if ($first != null){
                $out[] = $first;
            }
            while ($this->hasResult() && $item = $this->fetchResult()) {
                $out[] = $item;
            }

            if ($cache) {
                if (strpos(trim(strtolower($sql)), 'select') !== false) {
                    $this->_queryCache[$sql] = $out;
                }
            }
            return $out;

        } else {
            return false;
        }
    }
/**
 * Returns a single field of the first of query results for a given SQL query, or false if empty.
 *
 * @param string $name Name of the field
 * @param string $sql SQL query
 * @return unknown
 */
    function field($name, $sql) {
        $data = $this->fetchRow($sql);

        if (!isset($data[$name]) || empty($data[$name])) {
            return false;
        } else {
            return $data[$name];
        }
    }
/**
 * Returns a quoted name of $data for use in an SQL statement.
 * Strips fields out of SQL functions before quoting.
 *
 * @param string $data
 * @return string SQL field
 */
    function name($data) {
        if ($data == '*') {
            return '*';
        }
        $array = is_array($data);

        $data = (array)$data;
        $count = count($data);

        for($i = 0; $i < $count; $i++) {
            if ($data[$i] == '*') {
                continue;
            }
            if (strpos($data[$i], '(') !== false && preg_match_all('/([^(]*)\((.*)\)(.*)/', $data[$i], $fields)) {
                $fields = Set::extract($fields, '{n}.0');
                if (!empty($fields[1])) {
                    if (!empty($fields[2])) {
                        $data[$i] = $fields[1] . '(' . $this->name($fields[2]) . ')' . $fields[3];
                    } else {
                        $data[$i] = $fields[1] . '()' . $fields[3];
                    }
                }
            }
            $data[$i] = $this->startQuote . str_replace('.', $this->endQuote . '.' . $this->startQuote, $data[$i]) . $this->endQuote;
            $data[$i] = str_replace($this->startQuote . $this->startQuote, $this->startQuote, $data[$i]);
            if (strpos($data[$i], ' AS ')) {
                $data[$i] = str_replace(' AS ', $this->endQuote . ' AS ' . $this->startQuote, $data[$i]);
            }

            if (!empty($this->endQuote) && $this->endQuote == $this->startQuote) {
                if (substr_count($data[$i], $this->endQuote) % 2 == 1) {
                    $data[$i] = trim($data[$i], $this->endQuote);
                }
            }
            if (strpos($data[$i], '*')) {
                $data[$i] = str_replace($this->endQuote . '*' . $this->endQuote, '*', $data[$i]);
            }
            $data[$i] = str_replace($this->endQuote . $this->endQuote, $this->endQuote, $data[$i]);
        }
        if (!$array) {
            return $data[0];
        }
        return $data;
    }
/**
 * Checks if it's connected to the database
 *
 * @return boolean True if the database is connected, else false
 */
    function isConnected() {
        return $this->connected;
    }
/**
 * Checks if the result is valid
 *
 * @return boolean True if the result is valid else false
 */
    function hasResult() {
        return is_resource($this->_result);
    }
/**
 * Outputs the contents of the queries log.
 *
 * @param boolean $sorted
 */
    function showLog($sorted = false) {
        if ($sorted) {
            $log = sortByKey($this->_queriesLog, 'took', 'desc', SORT_NUMERIC);
        } else {
            $log = $this->_queriesLog;
        }

        if ($this->_queriesCnt > 1) {
            $text = 'queries';
        } else {
            $text = 'query';
        }

        if (php_sapi_name() != 'cli') {
            print ("<table class=\"cake-sql-log\" id=\"cakeSqlLog_" . preg_replace('/[^A-Za-z0-9_]/', '_', uniqid(time(), true)) . "\" summary=\"Cake SQL Log\" cellspacing=\"0\" border = \"0\">\n<caption>{$this->_queriesCnt} {$text} took {$this->_queriesTime} ms</caption>\n");
            print ("<thead>\n<tr><th>Nr</th><th>Query</th><th>Error</th><th>Affected</th><th>Num. rows</th><th>Took (ms)</th></tr>\n</thead>\n<tbody>\n");

            foreach ($log as $k => $i) {
                print ("<tr><td>" . ($k + 1) . "</td><td>" . h($i['query']) . "</td><td>{$i['error']}</td><td style = \"text-align: right\">{$i['affected']}</td><td style = \"text-align: right\">{$i['numRows']}</td><td style = \"text-align: right\">{$i['took']}</td></tr>\n");
            }
            print ("</tbody></table>\n");
        } else {
            foreach ($log as $k => $i) {
                print (($k + 1) . ". {$i['query']} {$i['error']}\n");
            }
        }
    }
/**
 * Log given SQL query.
 *
 * @param string $sql SQL statement
 * @todo: Add hook to log errors instead of returning false
 */
    function logQuery($sql) {
        $this->_queriesCnt++;
        $this->_queriesTime += $this->took;
        $this->_queriesLog[] = array(
            'query' => $sql,
            'error'     => $this->error,
            'affected'  => $this->affected,
            'numRows'   => $this->numRows,
            'took'      => $this->took
        );
        if (count($this->_queriesLog) > $this->_queriesLogMax) {
            array_pop($this->_queriesLog);
        }
        if ($this->error) {
            return false;
        }
    }
/**
 * Output information about an SQL query. The SQL statement, number of rows in resultset,
 * and execution time in microseconds. If the query fails, an error is output instead.
 *
 * @param string $sql Query to show information on.
 */
    function showQuery($sql) {
        $error = $this->error;
        if (strlen($sql) > 200 && !$this->fullDebug && Configure::read() > 1) {
            $sql = substr($sql, 0, 200) . '[...]';
        }
        if ($error && Configure::read() > 0) {
            $out = null;
            if ($error) {
                trigger_error("<span style = \"color:Red;text-align:left\"><b>SQL Error:</b> {$this->error}</span>", E_USER_WARNING);
            } else {
                $out = ("<small>[Aff:{$this->affected} Num:{$this->numRows} Took:{$this->took}ms]</small>");
            }
            e(sprintf("<p style = \"text-align:left\"><b>Query:</b> %s %s</p>", $sql, $out));
        }
    }
/**
 * Gets full table name including prefix
 *
 * @param mixed $model
 * @param boolean $quote
 * @return string Full quoted table name
 */
    function fullTableName($model, $quote = true) {
        if (is_object($model)) {
            $table = $model->tablePrefix . $model->table;
        } elseif (isset($this->config['prefix'])) {
            $table = $this->config['prefix'] . strval($model);
        } else {
            $table = strval($model);
        }
        if ($quote) {
            return $this->name($table);
        }
        return $table;
    }
/**
 * The "C" in CRUD
 *
 * @param Model $model
 * @param array $fields
 * @param array $values
 * @return boolean Success
 */
    function create(&$model, $fields = null, $values = null) {
        $id = null;

        if ($fields == null) {
            unset($fields, $values);
            $fields = array_keys($model->data);
            $values = array_values($model->data);
        }
        $count = count($fields);

        for ($i = 0; $i < $count; $i++) {
            $valueInsert[] = $this->value($values[$i], $model->getColumnType($fields[$i]));
        }
        for ($i = 0; $i < $count; $i++) {
            $fieldInsert[] = $this->name($fields[$i]);
            if ($fields[$i] == $model->primaryKey) {
                $id = $values[$i];
            }
        }

        if ($this->execute('INSERT INTO ' . $this->fullTableName($model) . ' (' . join(',', $fieldInsert). ') VALUES (' . join(',', $valueInsert) . ')')) {
            if (empty($id)) {
                $id = $this->lastInsertId($this->fullTableName($model, false), $model->primaryKey);
            }
            $model->setInsertID($id);
            $model->id = $id;
            return true;
        } else {
            $model->onError();
            return false;
        }
    }
/**
 * The "R" in CRUD
 *
 * @param Model $model
 * @param array $queryData
 * @param integer $recursive Number of levels of association
 * @return unknown
 */
    function read(&$model, $queryData = array(), $recursive = null) {
        $queryData = $this->__scrubQueryData($queryData);
        $null = null;
        $array = array();
        $linkedModels = array();
        $this->__bypass = false;
        $this->__booleans = array();

        if ($recursive === null && isset($queryData['recursive'])) {
            $recursive = $queryData['recursive'];
        }

        if (!is_null($recursive)) {
            $_recursive = $model->recursive;
            $model->recursive = $recursive;
        }

        if (!empty($queryData['fields'])) {
            $this->__bypass = true;
            $queryData['fields'] = $this->fields($model, null, $queryData['fields']);
        } else {
            $queryData['fields'] = $this->fields($model);
        }

        foreach ($model->__associations as $type) {
            foreach ($model->{$type} as $assoc => $assocData) {
                if ($model->recursive > -1) {
                    $linkModel =& $model->{$assoc};
                    $external = isset($assocData['external']);

                    if ($model->useDbConfig == $linkModel->useDbConfig) {
                        if (true === $this->generateAssociationQuery($model, $linkModel, $type, $assoc, $assocData, $queryData, $external, $null)) {
                            $linkedModels[] = $type . '/' . $assoc;
                        }
                    }
                }
            }
        }

        $query = $this->generateAssociationQuery($model, $null, null, null, null, $queryData, false, $null);
        $resultSet = $this->fetchAll($query, $model->cacheQueries, $model->alias);

        if ($resultSet === false) {
            $model->onError();
            return false;
        }

        $filtered = $this->__filterResults($resultSet, $model);

        if ($model->recursive > 0) {
            foreach ($model->__associations as $type) {
                foreach ($model->{$type} as $assoc => $assocData) {
                    $linkModel =& $model->{$assoc};

                    if (!in_array($type . '/' . $assoc, $linkedModels)) {
                        if ($model->useDbConfig == $linkModel->useDbConfig) {
                            $db =& $this;
                        } else {
                            $db =& ConnectionManager::getDataSource($linkModel->useDbConfig);
                        }
                    } elseif ($model->recursive > 1 && ($type == 'belongsTo' || $type == 'hasOne')) {
                        $db =& $this;
                    }

                    if (isset($db)) {
                        $stack = array($assoc);
                        $db->queryAssociation($model, $linkModel, $type, $assoc, $assocData, $array, true, $resultSet, $model->recursive - 1, $stack);
                        unset($db);
                    }
                }
            }
            $this->__filterResults($resultSet, $model, $filtered);
        }

        if (!is_null($recursive)) {
            $model->recursive = $_recursive;
        }
        return $resultSet;
    }
/**
 * Private method.  Passes association results thru afterFind filters of corresponding model
 *
 * @param array $results Reference of resultset to be filtered
 * @param object $model Instance of model to operate against
 * @param array $filtered List of classes already filtered, to be skipped
 * @return return
 */
    function __filterResults(&$results, &$model, $filtered = array()) {
        $filtering = array();
        $count = count($results);

        for ($i = 0; $i < $count; $i++) {
            if (is_array($results[$i])) {
                $classNames = array_keys($results[$i]);
                $count2 = count($classNames);

                for ($j = 0; $j < $count2; $j++) {
                    $className = $classNames[$j];

                    if ($model->alias != $className && !in_array($className, $filtered)) {
                        if (!in_array($className, $filtering)) {
                            $filtering[] = $className;
                        }

                        if (isset($model->{$className}) && is_object($model->{$className})) {
                            $data = $model->{$className}->afterFind(array(array($className => $results[$i][$className])), false);
                        }
                        if (isset($data[0][$className])) {
                            $results[$i][$className] = $data[0][$className];
                        }
                    }
                }
            }
        }
        return $filtering;
    }
/**
 * Enter description here...
 *
 * @param Model $model
 * @param unknown_type $linkModel
 * @param string $type Association type
 * @param unknown_type $association
 * @param unknown_type $assocData
 * @param unknown_type $queryData
 * @param unknown_type $external
 * @param unknown_type $resultSet
 * @param integer $recursive Number of levels of association
 * @param array $stack
 */
    function queryAssociation(&$model, &$linkModel, $type, $association, $assocData, &$queryData, $external = false, &$resultSet, $recursive, $stack) {
        if ($query = $this->generateAssociationQuery($model, $linkModel, $type, $association, $assocData, $queryData, $external, $resultSet)) {
            if (!isset($resultSet) || !is_array($resultSet)) {
                if (Configure::read() > 0) {
                    e('<div style = "font: Verdana bold 12px; color: #FF0000">' . sprintf(__('SQL Error in model %s:', true), $model->alias) . ' ');
                    if (isset($this->error) && $this->error != null) {
                        e($this->error);
                    }
                    e('</div>');
                }
                return null;
            }
            $count = count($resultSet);

            if ($type === 'hasMany' && empty($assocData['limit']) && !empty($assocData['foreignKey'])) {
                $ins = $fetch = array();
                for ($i = 0; $i < $count; $i++) {
                    if ($in = $this->insertQueryData('{$__cakeID__$}', $resultSet[$i], $association, $assocData, $model, $linkModel, $stack)) {
                        $ins[] = $in;
                    }
                }

                if (!empty($ins)) {
                    $fetch = $this->fetchAssociated($model, $query, $ins);
                }

                if (!empty($fetch) && is_array($fetch)) {
                    if ($recursive > 0) {
                        foreach ($linkModel->__associations as $type1) {
                            foreach ($linkModel->{$type1} as $assoc1 => $assocData1) {
                                $deepModel =& $linkModel->{$assoc1};
                                $tmpStack = $stack;
                                $tmpStack[] = $assoc1;

                                if ($linkModel->useDbConfig === $deepModel->useDbConfig) {
                                    $db =& $this;
                                } else {
                                    $db =& ConnectionManager::getDataSource($deepModel->useDbConfig);
                                }
                                $db->queryAssociation($linkModel, $deepModel, $type1, $assoc1, $assocData1, $queryData, true, $fetch, $recursive - 1, $tmpStack);
                            }
                        }
                    }
                }
                return $this->__mergeHasMany($resultSet, $fetch, $association, $model, $linkModel, $recursive);
            } elseif ($type === 'hasAndBelongsToMany') {
                $ins = $fetch = array();
                for ($i = 0; $i < $count; $i++) {
                    if ($in = $this->insertQueryData('{$__cakeID__$}', $resultSet[$i], $association, $assocData, $model, $linkModel, $stack)) {
                        $ins[] = $in;
                    }
                }
                if (!empty($ins)) {
                    if (count($ins) > 1) {
                        $query = str_replace('{$__cakeID__$}', '(' .join(', ', $ins) .')', $query);
                        $query = str_replace('= (', 'IN (', $query);
                        $query = str_replace('=  (', 'IN (', $query);
                    } else {
                        $query = str_replace('{$__cakeID__$}',$ins[0], $query);
                    }

                    $query = str_replace('  WHERE 1 = 1', '', $query);
                }

                $foreignKey = $model->hasAndBelongsToMany[$association]['foreignKey'];
                $joinKeys = array($foreignKey, $model->hasAndBelongsToMany[$association]['associationForeignKey']);
                list($with, $habtmFields) = $model->joinModel($model->hasAndBelongsToMany[$association]['with'], $joinKeys);
                $habtmFieldsCount = count($habtmFields);
                $q = $this->insertQueryData($query, null, $association, $assocData, $model, $linkModel, $stack);

                if ($q != false) {
                    $fetch = $this->fetchAll($q, $model->cacheQueries, $model->alias);
                } else {
                    $fetch = null;
                }
            }

            for ($i = 0; $i < $count; $i++) {
                $row =& $resultSet[$i];

                if ($type !== 'hasAndBelongsToMany') {
                    $q = $this->insertQueryData($query, $resultSet[$i], $association, $assocData, $model, $linkModel, $stack);
                    if ($q != false) {
                        $fetch = $this->fetchAll($q, $model->cacheQueries, $model->alias);
                    } else {
                        $fetch = null;
                    }
                }
                $selfJoin = false;

                if ($linkModel->name === $model->name) {
                    $selfJoin = true;
                }

                if (!empty($fetch) && is_array($fetch)) {
                    if ($recursive > 0) {
                        foreach ($linkModel->__associations as $type1) {
                            foreach ($linkModel->{$type1} as $assoc1 => $assocData1) {
                                $deepModel =& $linkModel->{$assoc1};

                                if (($type1 === 'belongsTo') || ($deepModel->alias === $model->alias && $type === 'belongsTo') || ($deepModel->alias != $model->alias)) {
                                    $tmpStack = $stack;
                                    $tmpStack[] = $assoc1;
                                    if ($linkModel->useDbConfig == $deepModel->useDbConfig) {
                                        $db =& $this;
                                    } else {
                                        $db =& ConnectionManager::getDataSource($deepModel->useDbConfig);
                                    }
                                    $db->queryAssociation($linkModel, $deepModel, $type1, $assoc1, $assocData1, $queryData, true, $fetch, $recursive - 1, $tmpStack);
                                }
                            }
                        }
                    }
                    if ($type == 'hasAndBelongsToMany') {
                        $uniqueIds = $merge = array();

                        foreach($fetch as $j => $data) {
                            if (
                                (isset($data[$with]) && $data[$with][$foreignKey] === $row[$model->alias][$model->primaryKey]) &&
                                (!in_array($data[$with][$joinKeys[1]], $uniqueIds))
                            ) {
                                $uniqueIds[] = $data[$with][$joinKeys[1]];

                                if ($habtmFieldsCount <= 2) {
                                    unset($data[$with]);
                                }
                                $merge[] = $data;
                            }
                        }
                        if (empty($merge) && !isset($row[$association])) {
                            $row[$association] = $merge;
                        } else {
                            $this->__mergeAssociation($resultSet[$i], $merge, $association, $type);
                        }
                    } else {
                        $this->__mergeAssociation($resultSet[$i], $fetch, $association, $type, $selfJoin);
                    }
                    $resultSet[$i][$association] = $linkModel->afterfind($resultSet[$i][$association]);

                } else {
                    $tempArray[0][$association] = false;
                    $this->__mergeAssociation($resultSet[$i], $tempArray, $association, $type, $selfJoin);
                }
            }
        }
    }
/**
 * A more efficient way to fetch associations.  Woohoo!
 *
 * @param model $model      Primary model object
 * @param string $query     Association query
 * @param array $ids        Array of IDs of associated records
 * @return array Association results
 */
    function fetchAssociated($model, $query, $ids) {
        $query = str_replace('{$__cakeID__$}', join(', ', $ids), $query);
        if (count($ids) > 1) {
            $query = str_replace('= (', 'IN (', $query);
            $query = str_replace('=  (', 'IN (', $query);
        }
        return $this->fetchAll($query, $model->cacheQueries, $model->alias);
    }

    function __mergeHasMany(&$resultSet, $merge, $association, &$model, &$linkModel) {
        foreach ($resultSet as $i => $value) {
            $count = 0;
            $merged[$association] = array();
            foreach ($merge as $j => $data) {
                if (isset($value[$model->alias]) && $value[$model->alias][$model->primaryKey] === $data[$association][$model->hasMany[$association]['foreignKey']]) {
                    if (count($data) > 1) {
                        $data = array_merge($data[$association], $data);
                        unset($data[$association]);
                        foreach ($data as $key => $name) {
                            if (is_numeric($key)) {
                                $data[$association][] = $name;
                                unset($data[$key]);
                            }
                        }
                        $merged[$association][] = $data;
                    } else {
                        $merged[$association][] = $data[$association];
                    }
                }
                $count++;
            }
            if (isset($value[$model->alias])) {
                $resultSet[$i] = Set::pushDiff($resultSet[$i], $merged);
                unset($merged);
            }
        }
    }
/**
 * Enter description here...
 *
 * @param unknown_type $data
 * @param unknown_type $merge
 * @param unknown_type $association
 * @param unknown_type $type
 * @param boolean $selfJoin
 */
    function __mergeAssociation(&$data, $merge, $association, $type, $selfJoin = false) {
        if (isset($merge[0]) && !isset($merge[0][$association])) {
            $association = Inflector::pluralize($association);
        }

        if ($type == 'belongsTo' || $type == 'hasOne') {
            if (isset($merge[$association])) {
                $data[$association] = $merge[$association][0];
            } else {
                if (count($merge[0][$association]) > 1) {
                    foreach ($merge[0] as $assoc => $data2) {
                        if ($assoc != $association) {
                            $merge[0][$association][$assoc] = $data2;
                        }
                    }
                }
                if (!isset($data[$association])) {
                    if ($merge[0][$association] != null) {
                        $data[$association] = $merge[0][$association];
                    } else {
                        $data[$association] = array();
                    }
                } else {
                    if (is_array($merge[0][$association])) {
                        foreach ($data[$association] as $k => $v) {
                            if (!is_array($v)) {
                                $dataAssocTmp[$k] = $v;
                            }
                        }

                        foreach ($merge[0][$association] as $k => $v) {
                            if (!is_array($v)) {
                                $mergeAssocTmp[$k] = $v;
                            }
                        }
                        $dataKeys = array_keys($data);
                        $mergeKeys = array_keys($merge[0]);

                        if ($mergeKeys[0] === $dataKeys[0] || $mergeKeys === $dataKeys) {
                            $data[$association][$association] = $merge[0][$association];
                        } else {
                            $diff = Set::diff($dataAssocTmp, $mergeAssocTmp);
                            $data[$association] = array_merge($merge[0][$association], $diff);
                        }
                    } elseif ($selfJoin && array_key_exists($association, $merge[0])) {
                        $data[$association] = array_merge($data[$association], array($association => array()));
                    }
                }
            }
        } else {
            if ($merge[0][$association] === false) {
                if (!isset($data[$association])) {
                    $data[$association] = array();
                }
            } else {
                foreach ($merge as $i => $row) {
                    if (count($row) == 1) {
                        if (empty($data[$association]) || (isset($data[$association]) && !in_array($row[$association], $data[$association]))) {
                            $data[$association][] = $row[$association];
                        }
                    } else {
                        $tmp = array_merge($row[$association], $row);
                        unset($tmp[$association]);
                        $data[$association][] = $tmp;
                    }
                }
            }
        }
    }
/**
 * Generates an array representing a query or part of a query from a single model or two associated models
 *
 * @param Model $model
 * @param Model $linkModel
 * @param string $type
 * @param string $association
 * @param array $assocData
 * @param array $queryData
 * @param boolean $external
 * @param array $resultSet
 * @return mixed
 */
    function generateAssociationQuery(&$model, &$linkModel, $type, $association = null, $assocData = array(), &$queryData, $external = false, &$resultSet) {
        $queryData = $this->__scrubQueryData($queryData);
        $assocData = $this->__scrubQueryData($assocData);

        if (empty($queryData['fields'])) {
            $queryData['fields'] = $this->fields($model, $model->alias);
        } elseif (!empty($model->hasMany) && $model->recursive > -1) {
            $assocFields = $this->fields($model, $model->alias, array("{$model->alias}.{$model->primaryKey}"));
            $passedFields = $this->fields($model, $model->alias, $queryData['fields']);

            if (count($passedFields) === 1) {
                $match = strpos($passedFields[0], $assocFields[0]);
                $match1 = strpos($passedFields[0], 'COUNT(');
                if ($match === false && $match1 === false) {
                    $queryData['fields'] = array_merge($passedFields, $assocFields);
                } else {
                    $queryData['fields'] = $passedFields;
                }
            } else {
                $queryData['fields'] = array_merge($passedFields, $assocFields);
            }
            unset($assocFields, $passedFields);
        }

        /* Saving for later refactor
            $tmpModel =& $model;

            if ($linkModel != null) {
                $tmpModel =& $linkModel;
            }
            foreach ($tmpModel->schema() as $field => $info) {
                if ($info['type'] == 'boolean') {
                    $this->_booleans[$tmpModel->alias][] = $field;
                }
            }
            unset($tmpModel);
        */

        if ($linkModel == null) {
            return $this->buildStatement(
                array(
                    'fields' => array_unique($queryData['fields']),
                    'table' => $this->fullTableName($model),
                    'alias' => $model->alias,
                    'limit' => $queryData['limit'],
                    'offset' => $queryData['offset'],
                    'joins' => $queryData['joins'],
                    'conditions' => $queryData['conditions'],
                    'order' => $queryData['order'],
                    'group' => $queryData['group']
                ),
                $model
            );
        }
        if ($external && !empty($assocData['finderQuery'])) {
            return $assocData['finderQuery'];
        }

        $alias = $association;
        $self = ($model->name == $linkModel->name);
        $fields = array();

        if ((!$external && in_array($type, array('hasOne', 'belongsTo')) && $this->__bypass === false) || $external) {
            $fields = $this->fields($linkModel, $alias, $assocData['fields']);
        }
        if (empty($assocData['offset']) && !empty($assocData['page'])) {
            $assocData['offset'] = ($assocData['page'] - 1) * $assocData['limit'];
        }
        $assocData['limit'] = $this->limit($assocData['limit'], $assocData['offset']);

        switch($type) {
            case 'hasOne':
            case 'belongsTo':
                $conditions = $this->__mergeConditions(
                    $assocData['conditions'],
                    $this->getConstraint($type, $model, $linkModel, $alias, array_merge($assocData, compact('external', 'self')))
                );
                if ($external) {
                    $query = array_merge($assocData, array(
                        'conditions' => $conditions,
                        'table' => $this->fullTableName($linkModel),
                        'fields' => $fields,
                        'alias' => $alias,
                        'group' => null
                    ));
                    $query = array_merge(array('order' => $assocData['order'], 'limit' => $assocData['limit']), $query);
                } else {
                    $join = array(
                        'table' => $this->fullTableName($linkModel),
                        'alias' => $alias,
                        'type' => isset($assocData['type']) ? $assocData['type'] : 'LEFT',
                        'conditions' => trim($this->conditions($conditions, true, false, $model))
                    );
                    $queryData['fields'] = array_merge($queryData['fields'], $fields);

                    if (!empty($assocData['order'])) {
                        $queryData['order'][] = $assocData['order'];
                    }
                    if (!in_array($join, $queryData['joins'])) {
                        $queryData['joins'][] = $join;
                    }
                    return true;
                }
            break;
            case 'hasMany':
                $assocData['fields'] = $this->fields($linkModel, $alias, $assocData['fields']);
                if (!empty($assocData['foreignKey'])) {
                    $assocData['fields'] = array_merge($assocData['fields'], $this->fields($linkModel, $alias, array("{$alias}.{$assocData['foreignKey']}")));
                }
                $query = array(
                    'conditions' => $this->__mergeConditions($this->getConstraint('hasMany', $model, $linkModel, $alias, $assocData), $assocData['conditions']),
                    'fields' => array_unique($assocData['fields']),
                    'table' => $this->fullTableName($linkModel),
                    'alias' => $alias,
                    'order' => $assocData['order'],
                    'limit' => $assocData['limit'],
                    'group' => null
                );
            break;
            case 'hasAndBelongsToMany':
                $joinFields = array();
                $joinAssoc = null;

                if (isset($assocData['with']) && !empty($assocData['with'])) {
                    $joinKeys = array($assocData['foreignKey'], $assocData['associationForeignKey']);
                    list($with, $joinFields) = $model->joinModel($assocData['with'], $joinKeys);

                    $joinTbl = $this->fullTableName($model->{$with});
                    $joinAlias = $joinTbl;

                    if (is_array($joinFields) && !empty($joinFields)) {
                        $joinFields = $this->fields($model->{$with}, $model->{$with}->alias, $joinFields);
                        $joinAssoc = $joinAlias = $model->{$with}->alias;
                    } else {
                        $joinFields = array();
                    }
                } else {
                    $joinTbl = $this->fullTableName($assocData['joinTable']);
                    $joinAlias = $joinTbl;
                }
                $query = array(
                    'conditions' => $assocData['conditions'],
                    'limit' => $assocData['limit'],
                    'table' => $this->fullTableName($linkModel),
                    'alias' => $alias,
                    'fields' => array_merge($this->fields($linkModel, $alias, $assocData['fields']), $joinFields),
                    'order' => $assocData['order'],
                    'group' => null,
                    'joins' => array(array(
                        'table' => $joinTbl,
                        'alias' => $joinAssoc,
                        'conditions' => $this->getConstraint('hasAndBelongsToMany', $model, $linkModel, $joinAlias, $assocData, $alias)
                    ))
                );
            break;
        }
        if (isset($query)) {
            return $this->buildStatement($query, $model);
        }
        return null;
    }
/**
 * Returns a conditions array for the constraint between two models
 *
 * @param string $type Association type
 * @param object $model Model object
 * @param array $association Association array
 * @return array Conditions array defining the constraint between $model and $association
 */
    function getConstraint($type, $model, $linkModel, $alias, $assoc, $alias2 = null) {
        $assoc = array_merge(array('external' => false, 'self' => false), $assoc);

        if (array_key_exists('foreignKey', $assoc) && empty($assoc['foreignKey'])) {
            return array();
        }

        switch (true) {
            case ($assoc['external'] && $type == 'hasOne'):
                return array("{$alias}.{$assoc['foreignKey']}" => '{$__cakeID__$}');
            break;
            case ($assoc['external'] && $type == 'belongsTo'):
                return array("{$alias}.{$linkModel->primaryKey}" => '{$__cakeForeignKey__$}');
            break;
            case (!$assoc['external'] && $type == 'hasOne'):
                return array("{$alias}.{$assoc['foreignKey']}" => $this->identifier("{$model->alias}.{$model->primaryKey}"));
            break;
            case (!$assoc['external'] && $type == 'belongsTo'):
                return array("{$model->alias}.{$assoc['foreignKey']}" => $this->identifier("{$alias}.{$linkModel->primaryKey}"));
            break;
            case ($type == 'hasMany'):
                return array("{$alias}.{$assoc['foreignKey']}" => array('{$__cakeID__$}'));
            break;
            case ($type == 'hasAndBelongsToMany'):
                return array(
                    array("{$alias}.{$assoc['foreignKey']}" => '{$__cakeID__$}'),
                    array("{$alias}.{$assoc['associationForeignKey']}" => $this->identifier("{$alias2}.{$linkModel->primaryKey}"))
                );
            break;
        }
        return array();
    }
/**
 * Builds and generates a JOIN statement from an array.  Handles final clean-up before conversion.
 *
 * @param array $join An array defining a JOIN statement in a query
 * @return string An SQL JOIN statement to be used in a query
 * @see DboSource::renderJoinStatement()
 * @see DboSource::buildStatement()
 */
    function buildJoinStatement($join) {
        $data = array_merge(array(
            'type' => null,
            'alias' => null,
            'table' => 'join_table',
            'conditions' => array()
        ), $join);

        if (!empty($data['alias'])) {
            $data['alias'] = $this->alias . $this->name($data['alias']);
        }
        if (!empty($data['conditions'])) {
            $data['conditions'] = trim($this->conditions($data['conditions'], true, false));
        }
        return $this->renderJoinStatement($data);
    }
/**
 * Builds and generates an SQL statement from an array.  Handles final clean-up before conversion.
 *
 * @param array $query An array defining an SQL query
 * @param object $model The model object which initiated the query
 * @return string An executable SQL statement
 * @see DboSource::renderStatement()
 */
    function buildStatement($query, $model) {
        $query = array_merge(array('offset' => null, 'joins' => array()), $query);
        if (!empty($query['joins'])) {
            for ($i = 0; $i < count($query['joins']); $i++) {
                if (is_array($query['joins'][$i])) {
                    $query['joins'][$i] = $this->buildJoinStatement($query['joins'][$i]);
                }
            }
        }
        return $this->renderStatement('select', array(
            'conditions' => $this->conditions($query['conditions'], true, true, $model),
            'fields' => join(', ', $query['fields']),
            'table' => $query['table'],
            'alias' => $this->alias . $this->name($query['alias']),
            'order' => $this->order($query['order']),
            'limit' => $this->limit($query['limit'], $query['offset']),
            'joins' => join(' ', $query['joins']),
            'group' => $this->group($query['group'])
        ));
    }
/**
 * Renders a final SQL JOIN statement
 *
 * @param array $data
 * @return string
 */
    function renderJoinStatement($data) {
        extract($data);
        return trim("{$type} JOIN {$table} {$alias} ON ({$conditions})");
    }
/**
 * Renders a final SQL statement by putting together the component parts in the correct order
 *
 * @param string $type
 * @param array $data
 * @return string
 */
    function renderStatement($type, $data) {
        extract($data);
        $aliases = null;

        switch (strtolower($type)) {
            case 'select':
                return "SELECT {$fields} FROM {$table} {$alias} {$joins} {$conditions} {$group} {$order} {$limit}";
            break;
            case 'update':
                if (!empty($alias)) {
                    $aliases = "{$this->alias}{$alias} {$joins} ";
                }
                return "UPDATE {$table} {$aliases}SET {$fields} {$conditions}";
            break;
            case 'delete':
                if (!empty($alias)) {
                    $aliases = "{$this->alias}{$alias} {$joins} ";
                }
                return "DELETE {$alias} FROM {$table} {$aliases}{$conditions}";
            break;
            case 'schema':
                foreach (array('columns', 'indexes') as $var) {
                    if (is_array(${$var})) {
                        ${$var} = "\t" . join(",\n\t", array_filter(${$var}));
                    }
                }
                if (trim($indexes) != '') {
                    $columns .= ',';
                }
                return "CREATE TABLE {$table} (\n{$columns}{$indexes});";
            break;
            case 'alter':
            break;
        }
    }
/**
 * Merges a mixed set of string/array conditions
 *
 * @return array
 */
    function __mergeConditions($query, $assoc) {
        if (!empty($assoc)) {
            if (is_array($query)) {
                return array_merge((array)$assoc, $query);
            } else {
                if (!empty($query)) {
                    $query = array($query);
                    if (is_array($assoc)) {
                        $query = array_merge($query, $assoc);
                    } else {
                        $query[] = $assoc;
                    }
                    return $query;
                } else {
                    return $assoc;
                }
            }
        }
        return $query;
    }
/**
 * Generates and executes an SQL UPDATE statement for given model, fields, and values.
 * For databases that do not support aliases in UPDATE queries.
 *
 * @param Model $model
 * @param array $fields
 * @param array $values
 * @param mixed $conditions