source: trunk/server/www/cake/libs/model/datasources/dbo_source.php @ 5

Last change on this file since 5 was 5, checked in by sander, 10 years ago

Import CakePHP base with custom Auth

File size: 71.1 KB
Line 
1<?php
2/* SVN FILE: $Id: dbo_source.php 7945 2008-12-19 02:16:01Z gwoo $ */
3/**
4 * Short description for file.
5 *
6 * Long description for file
7 *
8 * PHP versions 4 and 5
9 *
10 * CakePHP(tm) :  Rapid Development Framework (http://www.cakephp.org)
11 * Copyright 2005-2008, Cake Software Foundation, Inc. (http://www.cakefoundation.org)
12 *
13 * Licensed under The MIT License
14 * Redistributions of files must retain the above copyright notice.
15 *
16 * @filesource
17 * @copyright     Copyright 2005-2008, Cake Software Foundation, Inc. (http://www.cakefoundation.org)
18 * @link          http://www.cakefoundation.org/projects/info/cakephp CakePHP(tm) Project
19 * @package       cake
20 * @subpackage    cake.cake.libs.model.datasources
21 * @since         CakePHP(tm) v 0.10.0.1076
22 * @version       $Revision: 7945 $
23 * @modifiedby    $LastChangedBy: gwoo $
24 * @lastmodified  $Date: 2008-12-18 20:16:01 -0600 (Thu, 18 Dec 2008) $
25 * @license       http://www.opensource.org/licenses/mit-license.php The MIT License
26 */
27App::import('Core', array('Set', 'String'));
28
29/**
30 * DboSource
31 *
32 * Creates DBO-descendant objects from a given db connection configuration
33 *
34 * @package       cake
35 * @subpackage    cake.cake.libs.model.datasources
36 */
37class DboSource extends DataSource {
38/**
39 * Description string for this Database Data Source.
40 *
41 * @var unknown_type
42 */
43        var $description = "Database Data Source";
44/**
45 * index definition, standard cake, primary, index, unique
46 *
47 * @var array
48 */
49        var $index = array('PRI' => 'primary', 'MUL' => 'index', 'UNI' => 'unique');
50/**
51 * Database keyword used to assign aliases to identifiers.
52 *
53 * @var string
54 */
55        var $alias = 'AS ';
56/**
57 * Caches fields quoted in DboSource::name()
58 *
59 * @var array
60 */
61        var $fieldCache = array();
62/**
63 * Bypass automatic adding of joined fields/associations.
64 *
65 * @var boolean
66 */
67        var $__bypass = false;
68/**
69 * The set of valid SQL operations usable in a WHERE statement
70 *
71 * @var array
72 */
73        var $__sqlOps = array('like', 'ilike', 'or', 'not', 'in', 'between', 'regexp', 'similar to');
74/**
75 * Index of basic SQL commands
76 *
77 * @var array
78 * @access protected
79 */
80        var $_commands = array(
81                'begin'    => 'BEGIN',
82                'commit'   => 'COMMIT',
83                'rollback' => 'ROLLBACK'
84        );
85/**
86 * Constructor
87 */
88        function __construct($config = null, $autoConnect = true) {
89                if (!isset($config['prefix'])) {
90                        $config['prefix'] = '';
91                }
92                parent::__construct($config);
93                $this->fullDebug = Configure::read() > 1;
94
95                if ($autoConnect) {
96                        return $this->connect();
97                } else {
98                        return true;
99                }
100        }
101/**
102 * Reconnects to database server with optional new settings
103 *
104 * @param array $config An array defining the new configuration settings
105 * @return boolean True on success, false on failure
106 */
107        function reconnect($config = null) {
108                $this->disconnect();
109                $this->setConfig($config);
110                $this->_sources = null;
111
112                return $this->connect();
113        }
114/**
115 * Prepares a value, or an array of values for database queries by quoting and escaping them.
116 *
117 * @param mixed $data A value or an array of values to prepare.
118 * @param string $column The column into which this data will be inserted
119 * @param boolean $read Value to be used in READ or WRITE context
120 * @return mixed Prepared value or array of values.
121 */
122        function value($data, $column = null, $read = true) {
123                if (is_array($data) && !empty($data)) {
124                        return array_map(
125                                array(&$this, 'value'),
126                                $data, array_fill(0, count($data), $column), array_fill(0, count($data), $read)
127                        );
128                } elseif (is_object($data) && isset($data->type)) {
129                        if ($data->type == 'identifier') {
130                                return $this->name($data->value);
131                        } elseif ($data->type == 'expression') {
132                                return $data->value;
133                        }
134                } elseif (in_array($data, array('{$__cakeID__$}', '{$__cakeForeignKey__$}'), true)) {
135                        return $data;
136                } else {
137                        return null;
138                }
139        }
140/**
141 * Returns an object to represent a database identifier in a query
142 *
143 * @param string $identifier
144 * @return object An object representing a database identifier to be used in a query
145 */
146        function identifier($identifier) {
147                $obj = new stdClass();
148                $obj->type = 'identifier';
149                $obj->value = $identifier;
150                return $obj;
151        }
152/**
153 * Returns an object to represent a database expression in a query
154 *
155 * @param string $expression
156 * @return object An object representing a database expression to be used in a query
157 */
158        function expression($expression) {
159                $obj = new stdClass();
160                $obj->type = 'expression';
161                $obj->value = $expression;
162                return $obj;
163        }
164/**
165 * Executes given SQL statement.
166 *
167 * @param string $sql SQL statement
168 * @return unknown
169 */
170        function rawQuery($sql) {
171                $this->took = $this->error = $this->numRows = false;
172                return $this->execute($sql);
173        }
174/**
175 * Queries the database with given SQL statement, and obtains some metadata about the result
176 * (rows affected, timing, any errors, number of rows in resultset). The query is also logged.
177 * If DEBUG is set, the log is shown all the time, else it is only shown on errors.
178 *
179 * @param string $sql
180 * @param array $options
181 * @return mixed Resource or object representing the result set, or false on failure
182 */
183        function execute($sql, $options = array()) {
184                $defaults = array('stats' => true, 'log' => $this->fullDebug);
185                $options = array_merge($defaults, $options);
186
187                if ($options['stats']) {
188                        $t = getMicrotime();
189                        $this->_result = $this->_execute($sql);
190                        $this->took = round((getMicrotime() - $t) * 1000, 0);
191                        $this->affected = $this->lastAffected();
192                        $this->error = $this->lastError();
193                        $this->numRows = $this->lastNumRows();
194                }
195
196                if ($options['log']) {
197                        $this->logQuery($sql);
198                }
199
200                if ($this->error) {
201                        $this->showQuery($sql);
202                        return false;
203                } else {
204                        return $this->_result;
205                }
206        }
207/**
208 * DataSource Query abstraction
209 *
210 * @return resource Result resource identifier
211 */
212        function query() {
213                $args     = func_get_args();
214                $fields   = null;
215                $order    = null;
216                $limit    = null;
217                $page     = null;
218                $recursive = null;
219
220                if (count($args) == 1) {
221                        return $this->fetchAll($args[0]);
222
223                } elseif (count($args) > 1 && (strpos(strtolower($args[0]), 'findby') === 0 || strpos(strtolower($args[0]), 'findallby') === 0)) {
224                        $params = $args[1];
225
226                        if (strpos(strtolower($args[0]), 'findby') === 0) {
227                                $all  = false;
228                                $field = Inflector::underscore(preg_replace('/findBy/i', '', $args[0]));
229                        } else {
230                                $all  = true;
231                                $field = Inflector::underscore(preg_replace('/findAllBy/i', '', $args[0]));
232                        }
233
234                        $or = (strpos($field, '_or_') !== false);
235                        if ($or) {
236                                $field = explode('_or_', $field);
237                        } else {
238                                $field = explode('_and_', $field);
239                        }
240                        $off = count($field) - 1;
241
242                        if (isset($params[1 + $off])) {
243                                $fields = $params[1 + $off];
244                        }
245
246                        if (isset($params[2 + $off])) {
247                                $order = $params[2 + $off];
248                        }
249
250                        if (!array_key_exists(0, $params)) {
251                                return false;
252                        }
253
254                        $c = 0;
255                        $conditions = array();
256
257                        foreach ($field as $f) {
258                                $conditions[$args[2]->alias . '.' . $f] = $params[$c];
259                                $c++;
260                        }
261
262                        if ($or) {
263                                $conditions = array('OR' => $conditions);
264                        }
265
266                        if ($all) {
267                                if (isset($params[3 + $off])) {
268                                        $limit = $params[3 + $off];
269                                }
270
271                                if (isset($params[4 + $off])) {
272                                        $page = $params[4 + $off];
273                                }
274
275                                if (isset($params[5 + $off])) {
276                                        $recursive = $params[5 + $off];
277                                }
278                                return $args[2]->find('all', compact('conditions', 'fields', 'order', 'limit', 'page', 'recursive'));
279                        } else {
280                                if (isset($params[3 + $off])) {
281                                        $recursive = $params[3 + $off];
282                                }
283                                return $args[2]->find('first', compact('conditions', 'fields', 'order', 'recursive'));
284                        }
285                } else {
286                        if (isset($args[1]) && $args[1] === true) {
287                                return $this->fetchAll($args[0], true);
288                        } else if (isset($args[1]) && !is_array($args[1]) ) {
289                                return $this->fetchAll($args[0], false);
290                        } else if (isset($args[1]) && is_array($args[1])) {
291                                $offset = 0;
292                                if (isset($args[2])) {
293                                        $cache = $args[2];
294                                } else {
295                                        $cache = true;
296                                }
297                                $args[1] = array_map(array(&$this, 'value'), $args[1]);
298                                return $this->fetchAll(String::insert($args[0], $args[1]), $cache);
299                        }
300                }
301        }
302/**
303 * Returns a row from current resultset as an array
304 *
305 * @return array The fetched row as an array
306 */
307        function fetchRow($sql = null) {
308                if (!empty($sql) && is_string($sql) && strlen($sql) > 5) {
309                        if (!$this->execute($sql)) {
310                                return null;
311                        }
312                }
313
314                if ($this->hasResult()) {
315                        $this->resultSet($this->_result);
316                        $resultRow = $this->fetchResult();
317                        return $resultRow;
318                } else {
319                        return null;
320                }
321        }
322/**
323 * Returns an array of all result rows for a given SQL query.
324 * Returns false if no rows matched.
325 *
326 * @param string $sql SQL statement
327 * @param boolean $cache Enables returning/storing cached query results
328 * @return array Array of resultset rows, or false if no rows matched
329 */
330        function fetchAll($sql, $cache = true, $modelName = null) {
331                if ($cache && isset($this->_queryCache[$sql])) {
332                        if (preg_match('/^\s*select/i', $sql)) {
333                                return $this->_queryCache[$sql];
334                        }
335                }
336
337                if ($this->execute($sql)) {
338                        $out = array();
339
340                        $first = $this->fetchRow();
341                        if ($first != null) {
342                                $out[] = $first;
343                        }
344                        while ($this->hasResult() && $item = $this->fetchResult()) {
345                                $out[] = $item;
346                        }
347
348                        if ($cache) {
349                                if (strpos(trim(strtolower($sql)), 'select') !== false) {
350                                        $this->_queryCache[$sql] = $out;
351                                }
352                        }
353                        return $out;
354
355                } else {
356                        return false;
357                }
358        }
359/**
360 * Returns a single field of the first of query results for a given SQL query, or false if empty.
361 *
362 * @param string $name Name of the field
363 * @param string $sql SQL query
364 * @return unknown
365 */
366        function field($name, $sql) {
367                $data = $this->fetchRow($sql);
368
369                if (!isset($data[$name]) || empty($data[$name])) {
370                        return false;
371                } else {
372                        return $data[$name];
373                }
374        }
375/**
376 * Returns a quoted name of $data for use in an SQL statement.
377 * Strips fields out of SQL functions before quoting.
378 *
379 * @param string $data
380 * @return string SQL field
381 */
382        function name($data) {
383                if ($data == '*') {
384                        return '*';
385                }
386                if (is_object($data) && isset($data->type)) {
387                        return $data->value;
388                }
389                $array = is_array($data);
390                $data = (array)$data;
391                $count = count($data);
392
393                for ($i = 0; $i < $count; $i++) {
394                        if ($data[$i] == '*') {
395                                continue;
396                        }
397                        if (strpos($data[$i], '(') !== false && preg_match_all('/([^(]*)\((.*)\)(.*)/', $data[$i], $fields)) {
398                                $fields = Set::extract($fields, '{n}.0');
399
400                                if (!empty($fields[1])) {
401                                        if (!empty($fields[2])) {
402                                                $data[$i] = $fields[1] . '(' . $this->name($fields[2]) . ')' . $fields[3];
403                                        } else {
404                                                $data[$i] = $fields[1] . '()' . $fields[3];
405                                        }
406                                }
407                        }
408                        $data[$i] = str_replace('.', $this->endQuote . '.' . $this->startQuote, $data[$i]);
409                        $data[$i] = $this->startQuote . $data[$i] . $this->endQuote;
410                        $data[$i] = str_replace($this->startQuote . $this->startQuote, $this->startQuote, $data[$i]);
411                        $data[$i] = str_replace($this->startQuote . '(', '(', $data[$i]);
412                        $data[$i] = str_replace(')' . $this->startQuote, ')', $data[$i]);
413
414                        if (strpos($data[$i], ' AS ')) {
415                                $data[$i] = str_replace(' AS ', $this->endQuote . ' AS ' . $this->startQuote, $data[$i]);
416                        }
417                        if (!empty($this->endQuote) && $this->endQuote == $this->startQuote) {
418                                if (substr_count($data[$i], $this->endQuote) % 2 == 1) {
419                                        $data[$i] = trim($data[$i], $this->endQuote);
420                                }
421                        }
422                        if (strpos($data[$i], '*')) {
423                                $data[$i] = str_replace($this->endQuote . '*' . $this->endQuote, '*', $data[$i]);
424                        }
425                        $data[$i] = str_replace($this->endQuote . $this->endQuote, $this->endQuote, $data[$i]);
426                }
427                return (!$array) ? $data[0] : $data;
428        }
429/**
430 * Checks if it's connected to the database
431 *
432 * @return boolean True if the database is connected, else false
433 */
434        function isConnected() {
435                return $this->connected;
436        }
437/**
438 * Checks if the result is valid
439 *
440 * @return boolean True if the result is valid else false
441 */
442        function hasResult() {
443                return is_resource($this->_result);
444        }
445/**
446 * Outputs the contents of the queries log.
447 *
448 * @param boolean $sorted
449 */
450        function showLog($sorted = false) {
451                if ($sorted) {
452                        $log = sortByKey($this->_queriesLog, 'took', 'desc', SORT_NUMERIC);
453                } else {
454                        $log = $this->_queriesLog;
455                }
456
457                if ($this->_queriesCnt > 1) {
458                        $text = 'queries';
459                } else {
460                        $text = 'query';
461                }
462
463                if (PHP_SAPI != 'cli') {
464                        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->configKeyName}) {$this->_queriesCnt} {$text} took {$this->_queriesTime} ms</caption>\n");
465                        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");
466
467                        foreach ($log as $k => $i) {
468                                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");
469                        }
470                        print ("</tbody></table>\n");
471                } else {
472                        foreach ($log as $k => $i) {
473                                print (($k + 1) . ". {$i['query']} {$i['error']}\n");
474                        }
475                }
476        }
477/**
478 * Log given SQL query.
479 *
480 * @param string $sql SQL statement
481 * @todo: Add hook to log errors instead of returning false
482 */
483        function logQuery($sql) {
484                $this->_queriesCnt++;
485                $this->_queriesTime += $this->took;
486                $this->_queriesLog[] = array(
487                        'query' => $sql,
488                        'error'         => $this->error,
489                        'affected'      => $this->affected,
490                        'numRows'       => $this->numRows,
491                        'took'          => $this->took
492                );
493                if (count($this->_queriesLog) > $this->_queriesLogMax) {
494                        array_pop($this->_queriesLog);
495                }
496                if ($this->error) {
497                        return false;
498                }
499        }
500/**
501 * Output information about an SQL query. The SQL statement, number of rows in resultset,
502 * and execution time in microseconds. If the query fails, an error is output instead.
503 *
504 * @param string $sql Query to show information on.
505 */
506        function showQuery($sql) {
507                $error = $this->error;
508                if (strlen($sql) > 200 && !$this->fullDebug && Configure::read() > 1) {
509                        $sql = substr($sql, 0, 200) . '[...]';
510                }
511                if ($error && Configure::read() > 0) {
512                        $out = null;
513                        if ($error) {
514                                trigger_error("<span style = \"color:Red;text-align:left\"><b>SQL Error:</b> {$this->error}</span>", E_USER_WARNING);
515                        } else {
516                                $out = ("<small>[Aff:{$this->affected} Num:{$this->numRows} Took:{$this->took}ms]</small>");
517                        }
518                        pr(sprintf("<p style = \"text-align:left\"><b>Query:</b> %s %s</p>", $sql, $out));
519                }
520        }
521/**
522 * Gets full table name including prefix
523 *
524 * @param mixed $model
525 * @param boolean $quote
526 * @return string Full quoted table name
527 */
528        function fullTableName($model, $quote = true) {
529                if (is_object($model)) {
530                        $table = $model->tablePrefix . $model->table;
531                } elseif (isset($this->config['prefix'])) {
532                        $table = $this->config['prefix'] . strval($model);
533                } else {
534                        $table = strval($model);
535                }
536                if ($quote) {
537                        return $this->name($table);
538                }
539                return $table;
540        }
541/**
542 * The "C" in CRUD
543 *
544 * @param Model $model
545 * @param array $fields
546 * @param array $values
547 * @return boolean Success
548 */
549        function create(&$model, $fields = null, $values = null) {
550                $id = null;
551
552                if ($fields == null) {
553                        unset($fields, $values);
554                        $fields = array_keys($model->data);
555                        $values = array_values($model->data);
556                }
557                $count = count($fields);
558
559                for ($i = 0; $i < $count; $i++) {
560                        $valueInsert[] = $this->value($values[$i], $model->getColumnType($fields[$i]), false);
561                }
562                for ($i = 0; $i < $count; $i++) {
563                        $fieldInsert[] = $this->name($fields[$i]);
564                        if ($fields[$i] == $model->primaryKey) {
565                                $id = $values[$i];
566                        }
567                }
568                $query = array(
569                        'table' => $this->fullTableName($model),
570                        'fields' => join(', ', $fieldInsert),
571                        'values' => join(', ', $valueInsert)
572                );
573
574                if ($this->execute($this->renderStatement('create', $query))) {
575                        if (empty($id)) {
576                                $id = $this->lastInsertId($this->fullTableName($model, false), $model->primaryKey);
577                        }
578                        $model->setInsertID($id);
579                        $model->id = $id;
580                        return true;
581                } else {
582                        $model->onError();
583                        return false;
584                }
585        }
586/**
587 * The "R" in CRUD
588 *
589 * @param Model $model
590 * @param array $queryData
591 * @param integer $recursive Number of levels of association
592 * @return unknown
593 */
594        function read(&$model, $queryData = array(), $recursive = null) {
595                $queryData = $this->__scrubQueryData($queryData);
596
597                $null = null;
598                $array = array();
599                $linkedModels = array();
600                $this->__bypass = false;
601                $this->__booleans = array();
602
603                if ($recursive === null && isset($queryData['recursive'])) {
604                        $recursive = $queryData['recursive'];
605                }
606
607                if (!is_null($recursive)) {
608                        $_recursive = $model->recursive;
609                        $model->recursive = $recursive;
610                }
611
612                if (!empty($queryData['fields'])) {
613                        $this->__bypass = true;
614                        $queryData['fields'] = $this->fields($model, null, $queryData['fields']);
615                } else {
616                        $queryData['fields'] = $this->fields($model);
617                }
618
619                foreach ($model->__associations as $type) {
620                        foreach ($model->{$type} as $assoc => $assocData) {
621                                if ($model->recursive > -1) {
622                                        $linkModel =& $model->{$assoc};
623                                        $external = isset($assocData['external']);
624
625                                        if ($model->useDbConfig == $linkModel->useDbConfig) {
626                                                if (true === $this->generateAssociationQuery($model, $linkModel, $type, $assoc, $assocData, $queryData, $external, $null)) {
627                                                        $linkedModels[] = $type . '/' . $assoc;
628                                                }
629                                        }
630                                }
631                        }
632                }
633
634                $query = $this->generateAssociationQuery($model, $null, null, null, null, $queryData, false, $null);
635
636                $resultSet = $this->fetchAll($query, $model->cacheQueries, $model->alias);
637
638                if ($resultSet === false) {
639                        $model->onError();
640                        return false;
641                }
642
643                $filtered = $this->__filterResults($resultSet, $model);
644
645                if ($model->recursive > 0) {
646                        foreach ($model->__associations as $type) {
647                                foreach ($model->{$type} as $assoc => $assocData) {
648                                        $linkModel =& $model->{$assoc};
649
650                                        if (!in_array($type . '/' . $assoc, $linkedModels)) {
651                                                if ($model->useDbConfig == $linkModel->useDbConfig) {
652                                                        $db =& $this;
653                                                } else {
654                                                        $db =& ConnectionManager::getDataSource($linkModel->useDbConfig);
655                                                }
656                                        } elseif ($model->recursive > 1 && ($type == 'belongsTo' || $type == 'hasOne')) {
657                                                $db =& $this;
658                                        }
659
660                                        if (isset($db)) {
661                                                $stack = array($assoc);
662                                                $db->queryAssociation($model, $linkModel, $type, $assoc, $assocData, $array, true, $resultSet, $model->recursive - 1, $stack);
663                                                unset($db);
664                                        }
665                                }
666                        }
667                        $this->__filterResults($resultSet, $model, $filtered);
668                }
669
670                if (!is_null($recursive)) {
671                        $model->recursive = $_recursive;
672                }
673                return $resultSet;
674        }
675/**
676 * Private method.      Passes association results thru afterFind filters of corresponding model
677 *
678 * @param array $results Reference of resultset to be filtered
679 * @param object $model Instance of model to operate against
680 * @param array $filtered List of classes already filtered, to be skipped
681 * @return return
682 */
683        function __filterResults(&$results, &$model, $filtered = array()) {
684                $filtering = array();
685                $count = count($results);
686
687                for ($i = 0; $i < $count; $i++) {
688                        if (is_array($results[$i])) {
689                                $classNames = array_keys($results[$i]);
690                                $count2 = count($classNames);
691
692                                for ($j = 0; $j < $count2; $j++) {
693                                        $className = $classNames[$j];
694                                        if ($model->alias != $className && !in_array($className, $filtered)) {
695                                                if (!in_array($className, $filtering)) {
696                                                        $filtering[] = $className;
697                                                }
698
699                                                if (isset($model->{$className}) && is_object($model->{$className})) {
700                                                        $data = $model->{$className}->afterFind(array(array($className => $results[$i][$className])), false);
701                                                }
702                                                if (isset($data[0][$className])) {
703                                                        $results[$i][$className] = $data[0][$className];
704                                                }
705                                        }
706                                }
707                        }
708                }
709                return $filtering;
710        }
711/**
712 * Enter description here...
713 *
714 * @param Model $model
715 * @param unknown_type $linkModel
716 * @param string $type Association type
717 * @param unknown_type $association
718 * @param unknown_type $assocData
719 * @param unknown_type $queryData
720 * @param unknown_type $external
721 * @param unknown_type $resultSet
722 * @param integer $recursive Number of levels of association
723 * @param array $stack
724 */
725        function queryAssociation(&$model, &$linkModel, $type, $association, $assocData, &$queryData, $external = false, &$resultSet, $recursive, $stack) {
726                if ($query = $this->generateAssociationQuery($model, $linkModel, $type, $association, $assocData, $queryData, $external, $resultSet)) {
727                        if (!isset($resultSet) || !is_array($resultSet)) {
728                                if (Configure::read() > 0) {
729                                        e('<div style = "font: Verdana bold 12px; color: #FF0000">' . sprintf(__('SQL Error in model %s:', true), $model->alias) . ' ');
730                                        if (isset($this->error) && $this->error != null) {
731                                                e($this->error);
732                                        }
733                                        e('</div>');
734                                }
735                                return null;
736                        }
737                        $count = count($resultSet);
738
739                        if ($type === 'hasMany' && empty($assocData['limit']) && !empty($assocData['foreignKey'])) {
740                                $ins = $fetch = array();
741                                for ($i = 0; $i < $count; $i++) {
742                                        if ($in = $this->insertQueryData('{$__cakeID__$}', $resultSet[$i], $association, $assocData, $model, $linkModel, $stack)) {
743                                                $ins[] = $in;
744                                        }
745                                }
746
747                                if (!empty($ins)) {
748                                        $fetch = $this->fetchAssociated($model, $query, $ins);
749                                }
750
751                                if (!empty($fetch) && is_array($fetch)) {
752                                        if ($recursive > 0) {
753                                                foreach ($linkModel->__associations as $type1) {
754                                                        foreach ($linkModel->{$type1} as $assoc1 => $assocData1) {
755                                                                $deepModel =& $linkModel->{$assoc1};
756                                                                $tmpStack = $stack;
757                                                                $tmpStack[] = $assoc1;
758
759                                                                if ($linkModel->useDbConfig === $deepModel->useDbConfig) {
760                                                                        $db =& $this;
761                                                                } else {
762                                                                        $db =& ConnectionManager::getDataSource($deepModel->useDbConfig);
763                                                                }
764                                                                $db->queryAssociation($linkModel, $deepModel, $type1, $assoc1, $assocData1, $queryData, true, $fetch, $recursive - 1, $tmpStack);
765                                                        }
766                                                }
767                                        }
768                                }
769                                $this->__filterResults($fetch, $model);
770                                return $this->__mergeHasMany($resultSet, $fetch, $association, $model, $linkModel, $recursive);
771                        } elseif ($type === 'hasAndBelongsToMany') {
772                                $ins = $fetch = array();
773                                for ($i = 0; $i < $count; $i++) {
774                                        if ($in = $this->insertQueryData('{$__cakeID__$}', $resultSet[$i], $association, $assocData, $model, $linkModel, $stack)) {
775                                                $ins[] = $in;
776                                        }
777                                }
778                                if (!empty($ins)) {
779                                        if (count($ins) > 1) {
780                                                $query = str_replace('{$__cakeID__$}', '(' .join(', ', $ins) .')', $query);
781                                                $query = str_replace('= (', 'IN (', $query);
782                                                $query = str_replace('=  (', 'IN (', $query);
783                                        } else {
784                                                $query = str_replace('{$__cakeID__$}',$ins[0], $query);
785                                        }
786
787                                        $query = str_replace('  WHERE 1 = 1', '', $query);
788                                }
789
790                                $foreignKey = $model->hasAndBelongsToMany[$association]['foreignKey'];
791                                $joinKeys = array($foreignKey, $model->hasAndBelongsToMany[$association]['associationForeignKey']);
792                                list($with, $habtmFields) = $model->joinModel($model->hasAndBelongsToMany[$association]['with'], $joinKeys);
793                                $habtmFieldsCount = count($habtmFields);
794                                $q = $this->insertQueryData($query, null, $association, $assocData, $model, $linkModel, $stack);
795
796                                if ($q != false) {
797                                        $fetch = $this->fetchAll($q, $model->cacheQueries, $model->alias);
798                                } else {
799                                        $fetch = null;
800                                }
801                        }
802
803                        for ($i = 0; $i < $count; $i++) {
804                                $row =& $resultSet[$i];
805
806                                if ($type !== 'hasAndBelongsToMany') {
807                                        $q = $this->insertQueryData($query, $resultSet[$i], $association, $assocData, $model, $linkModel, $stack);
808                                        if ($q != false) {
809                                                $fetch = $this->fetchAll($q, $model->cacheQueries, $model->alias);
810                                        } else {
811                                                $fetch = null;
812                                        }
813                                }
814                                $selfJoin = false;
815
816                                if ($linkModel->name === $model->name) {
817                                        $selfJoin = true;
818                                }
819
820                                if (!empty($fetch) && is_array($fetch)) {
821                                        if ($recursive > 0) {
822                                                foreach ($linkModel->__associations as $type1) {
823                                                        foreach ($linkModel->{$type1} as $assoc1 => $assocData1) {
824                                                                $deepModel =& $linkModel->{$assoc1};
825
826                                                                if (($type1 === 'belongsTo') || ($deepModel->alias === $model->alias && $type === 'belongsTo') || ($deepModel->alias != $model->alias)) {
827                                                                        $tmpStack = $stack;
828                                                                        $tmpStack[] = $assoc1;
829                                                                        if ($linkModel->useDbConfig == $deepModel->useDbConfig) {
830                                                                                $db =& $this;
831                                                                        } else {
832                                                                                $db =& ConnectionManager::getDataSource($deepModel->useDbConfig);
833                                                                        }
834                                                                        $db->queryAssociation($linkModel, $deepModel, $type1, $assoc1, $assocData1, $queryData, true, $fetch, $recursive - 1, $tmpStack);
835                                                                }
836                                                        }
837                                                }
838                                        }
839                                        if ($type == 'hasAndBelongsToMany') {
840                                                $uniqueIds = $merge = array();
841
842                                                foreach ($fetch as $j => $data) {
843                                                        if (
844                                                                (isset($data[$with]) && $data[$with][$foreignKey] === $row[$model->alias][$model->primaryKey]) &&
845                                                                (!in_array($data[$with][$joinKeys[1]], $uniqueIds))
846                                                        ) {
847                                                                $uniqueIds[] = $data[$with][$joinKeys[1]];
848
849                                                                if ($habtmFieldsCount <= 2) {
850                                                                        unset($data[$with]);
851                                                                }
852                                                                $merge[] = $data;
853                                                        }
854                                                }
855                                                if (empty($merge) && !isset($row[$association])) {
856                                                        $row[$association] = $merge;
857                                                } else {
858                                                        $this->__mergeAssociation($resultSet[$i], $merge, $association, $type);
859                                                }
860                                        } else {
861                                                $this->__mergeAssociation($resultSet[$i], $fetch, $association, $type, $selfJoin);
862                                        }
863                                        if (isset($resultSet[$i][$association])) {
864                                                $resultSet[$i][$association] = $linkModel->afterFind($resultSet[$i][$association]);
865                                        }
866                                } else {
867                                        $tempArray[0][$association] = false;
868                                        $this->__mergeAssociation($resultSet[$i], $tempArray, $association, $type, $selfJoin);
869                                }
870                        }
871                }
872        }
873/**
874 * A more efficient way to fetch associations.  Woohoo!
875 *
876 * @param model $model          Primary model object
877 * @param string $query         Association query
878 * @param array $ids            Array of IDs of associated records
879 * @return array Association results
880 */
881        function fetchAssociated($model, $query, $ids) {
882                $query = str_replace('{$__cakeID__$}', join(', ', $ids), $query);
883                if (count($ids) > 1) {
884                        $query = str_replace('= (', 'IN (', $query);
885                        $query = str_replace('=  (', 'IN (', $query);
886                }
887                return $this->fetchAll($query, $model->cacheQueries, $model->alias);
888        }
889/**
890 * mergeHasMany - Merge the results of hasMany relations.
891 *
892 *
893 * @param array $resultSet Data to merge into
894 * @param array $merge Data to merge
895 * @param string $association Name of Model being Merged
896 * @param object $model Model being merged onto
897 * @param object $linkModel Model being merged
898 * @return void
899 **/
900        function __mergeHasMany(&$resultSet, $merge, $association, &$model, &$linkModel) {
901                foreach ($resultSet as $i => $value) {
902                        $count = 0;
903                        $merged[$association] = array();
904                        foreach ($merge as $j => $data) {
905                                if (isset($value[$model->alias]) && $value[$model->alias][$model->primaryKey] === $data[$association][$model->hasMany[$association]['foreignKey']]) {
906                                        if (count($data) > 1) {
907                                                $data = array_merge($data[$association], $data);
908                                                unset($data[$association]);
909                                                foreach ($data as $key => $name) {
910                                                        if (is_numeric($key)) {
911                                                                $data[$association][] = $name;
912                                                                unset($data[$key]);
913                                                        }
914                                                }
915                                                $merged[$association][] = $data;
916                                        } else {
917                                                $merged[$association][] = $data[$association];
918                                        }
919                                }
920                                $count++;
921                        }
922                        if (isset($value[$model->alias])) {
923                                $resultSet[$i] = Set::pushDiff($resultSet[$i], $merged);
924                                unset($merged);
925                        }
926                }
927        }
928/**
929 * Enter description here...
930 *
931 * @param unknown_type $data
932 * @param unknown_type $merge
933 * @param unknown_type $association
934 * @param unknown_type $type
935 * @param boolean $selfJoin
936 */
937        function __mergeAssociation(&$data, $merge, $association, $type, $selfJoin = false) {
938                if (isset($merge[0]) && !isset($merge[0][$association])) {
939                        $association = Inflector::pluralize($association);
940                }
941
942                if ($type == 'belongsTo' || $type == 'hasOne') {
943                        if (isset($merge[$association])) {
944                                $data[$association] = $merge[$association][0];
945                        } else {
946                                if (count($merge[0][$association]) > 1) {
947                                        foreach ($merge[0] as $assoc => $data2) {
948                                                if ($assoc != $association) {
949                                                        $merge[0][$association][$assoc] = $data2;
950                                                }
951                                        }
952                                }
953                                if (!isset($data[$association])) {
954                                        if ($merge[0][$association] != null) {
955                                                $data[$association] = $merge[0][$association];
956                                        } else {
957                                                $data[$association] = array();
958                                        }
959                                } else {
960                                        if (is_array($merge[0][$association])) {
961                                                foreach ($data[$association] as $k => $v) {
962                                                        if (!is_array($v)) {
963                                                                $dataAssocTmp[$k] = $v;
964                                                        }
965                                                }
966
967                                                foreach ($merge[0][$association] as $k => $v) {
968                                                        if (!is_array($v)) {
969                                                                $mergeAssocTmp[$k] = $v;
970                                                        }
971                                                }
972                                                $dataKeys = array_keys($data);
973                                                $mergeKeys = array_keys($merge[0]);
974
975                                                if ($mergeKeys[0] === $dataKeys[0] || $mergeKeys === $dataKeys) {
976                                                        $data[$association][$association] = $merge[0][$association];
977                                                } else {
978                                                        $diff = Set::diff($dataAssocTmp, $mergeAssocTmp);
979                                                        $data[$association] = array_merge($merge[0][$association], $diff);
980                                                }
981                                        } elseif ($selfJoin && array_key_exists($association, $merge[0])) {
982                                                $data[$association] = array_merge($data[$association], array($association => array()));
983                                        }
984                                }
985                        }
986                } else {
987                        if (isset($merge[0][$association]) && $merge[0][$association] === false) {
988                                if (!isset($data[$association])) {
989                                        $data[$association] = array();
990                                }
991                        } else {
992                                foreach ($merge as $i => $row) {
993                                        if (count($row) == 1) {
994                                                if (empty($data[$association]) || (isset($data[$association]) && !in_array($row[$association], $data[$association]))) {
995                                                        $data[$association][] = $row[$association];
996                                                }
997                                        } else if (!empty($row)) {
998                                                $tmp = array_merge($row[$association], $row);
999                                                unset($tmp[$association]);
1000                                                $data[$association][] = $tmp;
1001                                        }
1002                                }
1003                        }
1004                }
1005        }
1006/**
1007 * Generates an array representing a query or part of a query from a single model or two associated models
1008 *
1009 * @param Model $model
1010 * @param Model $linkModel
1011 * @param string $type
1012 * @param string $association
1013 * @param array $assocData
1014 * @param array $queryData
1015 * @param boolean $external
1016 * @param array $resultSet
1017 * @return mixed
1018 */
1019        function generateAssociationQuery(&$model, &$linkModel, $type, $association = null, $assocData = array(), &$queryData, $external = false, &$resultSet) {
1020                $queryData = $this->__scrubQueryData($queryData);
1021                $assocData = $this->__scrubQueryData($assocData);
1022
1023                if (empty($queryData['fields'])) {
1024                        $queryData['fields'] = $this->fields($model, $model->alias);
1025                } elseif (!empty($model->hasMany) && $model->recursive > -1) {
1026                        $assocFields = $this->fields($model, $model->alias, array("{$model->alias}.{$model->primaryKey}"));
1027                        $passedFields = $this->fields($model, $model->alias, $queryData['fields']);
1028
1029                        if (count($passedFields) === 1) {
1030                                $match = strpos($passedFields[0], $assocFields[0]);
1031                                $match1 = strpos($passedFields[0], 'COUNT(');
1032                                if ($match === false && $match1 === false) {
1033                                        $queryData['fields'] = array_merge($passedFields, $assocFields);
1034                                } else {
1035                                        $queryData['fields'] = $passedFields;
1036                                }
1037                        } else {
1038                                $queryData['fields'] = array_merge($passedFields, $assocFields);
1039                        }
1040                        unset($assocFields, $passedFields);
1041                }
1042
1043                if ($linkModel == null) {
1044                        return $this->buildStatement(
1045                                array(
1046                                        'fields' => array_unique($queryData['fields']),
1047                                        'table' => $this->fullTableName($model),
1048                                        'alias' => $model->alias,
1049                                        'limit' => $queryData['limit'],
1050                                        'offset' => $queryData['offset'],
1051                                        'joins' => $queryData['joins'],
1052                                        'conditions' => $queryData['conditions'],
1053                                        'order' => $queryData['order'],
1054                                        'group' => $queryData['group']
1055                                ),
1056                                $model
1057                        );
1058                }
1059                if ($external && !empty($assocData['finderQuery'])) {
1060                        return $assocData['finderQuery'];
1061                }
1062
1063                $alias = $association;
1064                $self = ($model->name == $linkModel->name);
1065                $fields = array();
1066
1067                if ((!$external && in_array($type, array('hasOne', 'belongsTo')) && $this->__bypass === false) || $external) {
1068                        $fields = $this->fields($linkModel, $alias, $assocData['fields']);
1069                }
1070                if (empty($assocData['offset']) && !empty($assocData['page'])) {
1071                        $assocData['offset'] = ($assocData['page'] - 1) * $assocData['limit'];
1072                }
1073                $assocData['limit'] = $this->limit($assocData['limit'], $assocData['offset']);
1074
1075                switch ($type) {
1076                        case 'hasOne':
1077                        case 'belongsTo':
1078                                $conditions = $this->__mergeConditions(
1079                                        $assocData['conditions'],
1080                                        $this->getConstraint($type, $model, $linkModel, $alias, array_merge($assocData, compact('external', 'self')))
1081                                );
1082
1083                                if (!$self && $external) {
1084                                        foreach ($conditions as $key => $condition) {
1085                                                if (is_numeric($key) && strpos($condition, $model->alias . '.') !== false) {
1086                                                        unset($conditions[$key]);
1087                                                }
1088                                        }
1089                                }
1090
1091                                if ($external) {
1092                                        $query = array_merge($assocData, array(
1093                                                'conditions' => $conditions,
1094                                                'table' => $this->fullTableName($linkModel),
1095                                                'fields' => $fields,
1096                                                'alias' => $alias,
1097                                                'group' => null
1098                                        ));
1099                                        $query = array_merge(array('order' => $assocData['order'], 'limit' => $assocData['limit']), $query);
1100                                } else {
1101                                        $join = array(
1102                                                'table' => $this->fullTableName($linkModel),
1103                                                'alias' => $alias,
1104                                                'type' => isset($assocData['type']) ? $assocData['type'] : 'LEFT',
1105                                                'conditions' => trim($this->conditions($conditions, true, false, $model))
1106                                        );
1107                                        $queryData['fields'] = array_merge($queryData['fields'], $fields);
1108
1109                                        if (!empty($assocData['order'])) {
1110                                                $queryData['order'][] = $assocData['order'];
1111                                        }
1112                                        if (!in_array($join, $queryData['joins'])) {
1113                                                $queryData['joins'][] = $join;
1114                                        }
1115                                        return true;
1116                                }
1117                        break;
1118                        case 'hasMany':
1119                                $assocData['fields'] = $this->fields($linkModel, $alias, $assocData['fields']);
1120                                if (!empty($assocData['foreignKey'])) {
1121                                        $assocData['fields'] = array_merge($assocData['fields'], $this->fields($linkModel, $alias, array("{$alias}.{$assocData['foreignKey']}")));
1122                                }
1123                                $query = array(
1124                                        'conditions' => $this->__mergeConditions($this->getConstraint('hasMany', $model, $linkModel, $alias, $assocData), $assocData['conditions']),
1125                                        'fields' => array_unique($assocData['fields']),
1126                                        'table' => $this->fullTableName($linkModel),
1127                                        'alias' => $alias,
1128                                        'order' => $assocData['order'],
1129                                        'limit' => $assocData['limit'],
1130                                        'group' => null
1131                                );
1132                        break;
1133                        case 'hasAndBelongsToMany':
1134                                $joinFields = array();
1135                                $joinAssoc = null;
1136
1137                                if (isset($assocData['with']) && !empty($assocData['with'])) {
1138                                        $joinKeys = array($assocData['foreignKey'], $assocData['associationForeignKey']);
1139                                        list($with, $joinFields) = $model->joinModel($assocData['with'], $joinKeys);
1140
1141                                        $joinTbl = $this->fullTableName($model->{$with});
1142                                        $joinAlias = $joinTbl;
1143
1144                                        if (is_array($joinFields) && !empty($joinFields)) {
1145                                                $joinFields = $this->fields($model->{$with}, $model->{$with}->alias, $joinFields);
1146                                                $joinAssoc = $joinAlias = $model->{$with}->alias;
1147                                        } else {
1148                                                $joinFields = array();
1149                                        }
1150                                } else {
1151                                        $joinTbl = $this->fullTableName($assocData['joinTable']);
1152                                        $joinAlias = $joinTbl;
1153                                }
1154                                $query = array(
1155                                        'conditions' => $assocData['conditions'],
1156                                        'limit' => $assocData['limit'],
1157                                        'table' => $this->fullTableName($linkModel),
1158                                        'alias' => $alias,
1159                                        'fields' => array_merge($this->fields($linkModel, $alias, $assocData['fields']), $joinFields),
1160                                        'order' => $assocData['order'],
1161                                        'group' => null,
1162                                        'joins' => array(array(
1163                                                'table' => $joinTbl,
1164                                                'alias' => $joinAssoc,
1165                                                'conditions' => $this->getConstraint('hasAndBelongsToMany', $model, $linkModel, $joinAlias, $assocData, $alias)
1166                                        ))
1167                                );
1168                        break;
1169                }
1170                if (isset($query)) {
1171                        return $this->buildStatement($query, $model);
1172                }
1173                return null;
1174        }
1175/**
1176 * Returns a conditions array for the constraint between two models
1177 *
1178 * @param string $type Association type
1179 * @param object $model Model object
1180 * @param array $association Association array
1181 * @return array Conditions array defining the constraint between $model and $association
1182 */
1183        function getConstraint($type, $model, $linkModel, $alias, $assoc, $alias2 = null) {
1184                $assoc = array_merge(array('external' => false, 'self' => false), $assoc);
1185
1186                if (array_key_exists('foreignKey', $assoc) && empty($assoc['foreignKey'])) {
1187                        return array();
1188                }
1189
1190                switch (true) {
1191                        case ($assoc['external'] && $type == 'hasOne'):
1192                                return array("{$alias}.{$assoc['foreignKey']}" => '{$__cakeID__$}');
1193                        break;
1194                        case ($assoc['external'] && $type == 'belongsTo'):
1195                                return array("{$alias}.{$linkModel->primaryKey}" => '{$__cakeForeignKey__$}');
1196                        break;
1197                        case (!$assoc['external'] && $type == 'hasOne'):
1198                                return array("{$alias}.{$assoc['foreignKey']}" => $this->identifier("{$model->alias}.{$model->primaryKey}"));
1199                        break;
1200                        case (!$assoc['external'] && $type == 'belongsTo'):
1201                                return array("{$model->alias}.{$assoc['foreignKey']}" => $this->identifier("{$alias}.{$linkModel->primaryKey}"));
1202                        break;
1203                        case ($type == 'hasMany'):
1204                                return array("{$alias}.{$assoc['foreignKey']}" => array('{$__cakeID__$}'));
1205                        break;
1206                        case ($type == 'hasAndBelongsToMany'):
1207                                return array(
1208                                        array("{$alias}.{$assoc['foreignKey']}" => '{$__cakeID__$}'),
1209                                        array("{$alias}.{$assoc['associationForeignKey']}" => $this->identifier("{$alias2}.{$linkModel->primaryKey}"))
1210                                );
1211                        break;
1212                }
1213                return array();
1214        }
1215/**
1216 * Builds and generates a JOIN statement from an array.  Handles final clean-up before conversion.
1217 *
1218 * @param array $join An array defining a JOIN statement in a query
1219 * @return string An SQL JOIN statement to be used in a query
1220 * @see DboSource::renderJoinStatement()
1221 * @see DboSource::buildStatement()
1222 */
1223        function buildJoinStatement($join) {
1224                $data = array_merge(array(
1225                        'type' => null,
1226                        'alias' => null,
1227                        'table' => 'join_table',
1228                        'conditions' => array()
1229                ), $join);
1230
1231                if (!empty($data['alias'])) {
1232                        $data['alias'] = $this->alias . $this->name($data['alias']);
1233                }
1234                if (!empty($data['conditions'])) {
1235                        $data['conditions'] = trim($this->conditions($data['conditions'], true, false));
1236                }
1237                return $this->renderJoinStatement($data);
1238        }
1239/**
1240 * Builds and generates an SQL statement from an array.  Handles final clean-up before conversion.
1241 *
1242 * @param array $query An array defining an SQL query
1243 * @param object $model The model object which initiated the query
1244 * @return string An executable SQL statement
1245 * @see DboSource::renderStatement()
1246 */
1247        function buildStatement($query, $model) {
1248                $query = array_merge(array('offset' => null, 'joins' => array()), $query);
1249                if (!empty($query['joins'])) {
1250                        $count = count($query['joins']);
1251                        for ($i = 0; $i < $count; $i++) {
1252                                if (is_array($query['joins'][$i])) {
1253                                        $query['joins'][$i] = $this->buildJoinStatement($query['joins'][$i]);
1254                                }
1255                        }
1256                }
1257                return $this->renderStatement('select', array(
1258                        'conditions' => $this->conditions($query['conditions'], true, true, $model),
1259                        'fields' => join(', ', $query['fields']),
1260                        'table' => $query['table'],
1261                        'alias' => $this->alias . $this->name($query['alias']),
1262                        'order' => $this->order($query['order']),
1263                        'limit' => $this->limit($query['limit'], $query['offset']),
1264                        'joins' => join(' ', $query['joins']),
1265                        'group' => $this->group($query['group'])
1266                ));
1267        }
1268/**
1269 * Renders a final SQL JOIN statement
1270 *
1271 * @param array $data
1272 * @return string
1273 */
1274        function renderJoinStatement($data) {
1275                extract($data);
1276                return trim("{$type} JOIN {$table} {$alias} ON ({$conditions})");
1277        }
1278/**
1279 * Renders a final SQL statement by putting together the component parts in the correct order
1280 *
1281 * @param string $type
1282 * @param array $data
1283 * @return string
1284 */
1285        function renderStatement($type, $data) {
1286                extract($data);
1287                $aliases = null;
1288
1289                switch (strtolower($type)) {
1290                        case 'select':
1291                                return "SELECT {$fields} FROM {$table} {$alias} {$joins} {$conditions} {$group} {$order} {$limit}";
1292                        break;
1293                        case 'create':
1294                                return "INSERT INTO {$table} ({$fields}) VALUES ({$values})";
1295                        break;
1296                        case 'update':
1297                                if (!empty($alias)) {
1298                                        $aliases = "{$this->alias}{$alias} {$joins} ";
1299                                }
1300                                return "UPDATE {$table} {$aliases}SET {$fields} {$conditions}";
1301                        break;
1302                        case 'delete':
1303                                if (!empty($alias)) {
1304                                        $aliases = "{$this->alias}{$alias} {$joins} ";
1305                                }
1306                                return "DELETE {$alias} FROM {$table} {$aliases}{$conditions}";
1307                        break;
1308                        case 'schema':
1309                                foreach (array('columns', 'indexes') as $var) {
1310                                        if (is_array(${$var})) {
1311                                                ${$var} = "\t" . join(",\n\t", array_filter(${$var}));
1312                                        }
1313                                }
1314                                if (trim($indexes) != '') {
1315                                        $columns .= ',';
1316                                }
1317                                return "CREATE TABLE {$table} (\n{$columns}{$indexes});";
1318                        break;
1319                        case 'alter':
1320                        break;
1321                }
1322        }
1323/**
1324 * Merges a mixed set of string/array conditions
1325 *
1326 * @return array
1327 */
1328        function __mergeConditions($query, $assoc) {
1329                if (empty($assoc)) {
1330                        return $query;
1331                }
1332
1333                if (is_array($query)) {
1334                        return array_merge((array)$assoc, $query);
1335                }
1336
1337                if (!empty($query)) {
1338                        $query = array($query);
1339                        if (is_array($assoc)) {
1340                                $query = array_merge($query, $assoc);
1341                        } else {
1342                                $query[] = $assoc;
1343                        }
1344                        return $query;
1345                }
1346
1347                return $assoc;
1348        }
1349/**
1350 * Generates and executes an SQL UPDATE statement for given model, fields, and values.
1351 * For databases that do not support aliases in UPDATE queries.
1352 *
1353 * @param Model $model
1354 * @param array $fields
1355 * @param array $values
1356 * @param mixed $conditions
1357 * @return boolean Success
1358 */
1359        function update(&$model, $fields = array(), $values = null, $conditions = null) {
1360                if ($values == null) {
1361                        $combined = $fields;
1362                } else {
1363                        $combined = array_combine($fields, $values);
1364                }
1365                $fields = join(', ', $this->_prepareUpdateFields($model, $combined, empty($conditions)));
1366
1367                $alias = $joins = null;
1368                $table = $this->fullTableName($model);
1369                $conditions = $this->_matchRecords($model, $conditions);
1370
1371                if ($conditions === false) {
1372                        return false;
1373                }
1374                $query = compact('table', 'alias', 'joins', 'fields', 'conditions');
1375
1376                if (!$this->execute($this->renderStatement('update', $query))) {
1377                        $model->onError();
1378                        return false;
1379                }
1380                return true;
1381        }
1382/**
1383 * Quotes and prepares fields and values for an SQL UPDATE statement
1384 *
1385 * @param Model $model
1386 * @param array $fields
1387 * @param boolean $quoteValues If values should be quoted, or treated as SQL snippets
1388 * @param boolean $alias Include the model alias in the field name
1389 * @return array Fields and values, quoted and preparted
1390 * @access protected
1391 */
1392        function _prepareUpdateFields(&$model, $fields, $quoteValues = true, $alias = false) {
1393                $quotedAlias = $this->startQuote . $model->alias . $this->startQuote;
1394                foreach ($fields as $field => $value) {
1395                        if ($alias && strpos($field, '.') === false) {
1396                                $quoted = $model->escapeField($field);
1397                        } elseif (!$alias && strpos($field, '.') !== false) {
1398                                $quoted = $this->name(str_replace($quotedAlias . '.', '', str_replace(
1399                                        $model->alias . '.', '', $field
1400                                )));
1401                        } else {
1402                                $quoted = $this->name($field);
1403                        }
1404
1405                        if ($value === null) {
1406                                $updates[] = $quoted . ' = NULL';
1407                        } else {
1408                                $update = $quoted . ' = ';
1409                                if ($quoteValues) {
1410                                        $update .= $this->value($value, $model->getColumnType($field), false);
1411                                } elseif (!$alias) {
1412                                        $update .= str_replace($quotedAlias . '.', '', str_replace(
1413                                                $model->alias . '.', '', $value
1414                                        ));
1415                                } else {
1416                                        $update .= $value;
1417                                }
1418                                $updates[] =  $update;
1419                        }
1420                }
1421                return $updates;
1422        }
1423/**
1424 * Generates and executes an SQL DELETE statement.
1425 * For databases that do not support aliases in UPDATE queries.
1426 *
1427 * @param Model $model
1428 * @param mixed $conditions
1429 * @return boolean Success
1430 */
1431        function delete(&$model, $conditions = null) {
1432                $alias = $joins = null;
1433                $table = $this->fullTableName($model);
1434                $conditions = $this->_matchRecords($model, $conditions);
1435
1436                if ($conditions === false) {
1437                        return false;
1438                }
1439
1440                if ($this->execute($this->renderStatement('delete', compact('alias', 'table', 'joins', 'conditions'))) === false) {
1441                        $model->onError();
1442                        return false;
1443                }
1444                return true;
1445        }
1446/**
1447 * Gets a list of record IDs for the given conditions.  Used for multi-record updates and deletes
1448 * in databases that do not support aliases in UPDATE/DELETE queries.
1449 *
1450 * @param Model $model
1451 * @param mixed $conditions
1452 * @return array List of record IDs
1453 * @access protected
1454 */
1455        function _matchRecords(&$model, $conditions = null) {
1456                if ($conditions === true) {
1457                        $conditions = $this->conditions(true);
1458                } elseif ($conditions === null) {
1459                        $conditions = $this->conditions($this->defaultConditions($model, $conditions, false), true, true, $model);
1460                } else {
1461                        $idList = $model->find('all', array(
1462                                'fields' => "{$model->alias}.{$model->primaryKey}",
1463                                'conditions' => $conditions
1464                        ));
1465
1466                        if (empty($idList)) {
1467                                return false;
1468                        }
1469                        $conditions = $this->conditions(array(
1470                                $model->primaryKey => Set::extract($idList, "{n}.{$model->alias}.{$model->primaryKey}")
1471                        ));
1472                }
1473                return $conditions;
1474        }
1475/**
1476 * Returns an array of SQL JOIN fragments from a model's associations
1477 *
1478 * @param object $model
1479 * @return array
1480 */
1481        function _getJoins($model) {
1482                $join = array();
1483                $joins = array_merge($model->getAssociated('hasOne'), $model->getAssociated('belongsTo'));
1484
1485                foreach ($joins as $assoc) {
1486                        if (isset($model->{$assoc}) && $model->useDbConfig == $model->{$assoc}->useDbConfig) {
1487                                $assocData = $model->getAssociated($assoc);
1488                                $join[] = $this->buildJoinStatement(array(
1489                                        'table' => $this->fullTableName($model->{$assoc}),
1490                                        'alias' => $assoc,
1491                                        'type' => isset($assocData['type']) ? $assocData['type'] : 'LEFT',
1492                                        'conditions' => trim($this->conditions(
1493                                                $this->getConstraint($assocData['association'], $model, $model->{$assoc}, $assoc, $assocData),
1494                                                true, false, $model
1495                                        ))
1496                                ));
1497                        }
1498                }
1499                return $join;
1500        }
1501/**
1502 * Returns the an SQL calculation, i.e. COUNT() or MAX()
1503 *
1504 * @param model $model
1505 * @param string $func Lowercase name of SQL function, i.e. 'count' or 'max'
1506 * @param array $params Function parameters (any values must be quoted manually)
1507 * @return string       An SQL calculation function
1508 * @access public
1509 */
1510        function calculate(&$model, $func, $params = array()) {
1511                $params = (array)$params;
1512
1513                switch (strtolower($func)) {
1514                        case 'count':
1515                                if (!isset($params[0])) {
1516                                        $params[0] = '*';
1517                                }
1518                                if (!isset($params[1])) {
1519                                        $params[1] = 'count';
1520                                }
1521                                return 'COUNT(' . $this->name($params[0]) . ') AS ' . $this->name($params[1]);
1522                        case 'max':
1523                        case 'min':
1524                                if (!isset($params[1])) {
1525                                        $params[1] = $params[0];
1526                                }
1527                                return strtoupper($func) . '(' . $this->name($params[0]) . ') AS ' . $this->name($params[1]);
1528                        break;
1529                }
1530        }
1531/**
1532 * Deletes all the records in a table and resets the count of the auto-incrementing
1533 * primary key, where applicable.
1534 *
1535 * @param mixed $table A string or model class representing the table to be truncated
1536 * @return boolean      SQL TRUNCATE TABLE statement, false if not applicable.
1537 * @access public
1538 */
1539        function truncate($table) {
1540                return $this->execute('TRUNCATE TABLE ' . $this->fullTableName($table));
1541        }
1542/**
1543 * Begin a transaction
1544 *
1545 * @param model $model
1546 * @return boolean True on success, false on fail
1547 * (i.e. if the database/model does not support transactions,
1548 * or a transaction has not started).
1549 */
1550        function begin(&$model) {
1551                if (parent::begin($model) && $this->execute($this->_commands['begin'])) {
1552                        $this->_transactionStarted = true;
1553                        return true;
1554                }
1555                return false;
1556        }
1557/**
1558 * Commit a transaction
1559 *
1560 * @param model $model
1561 * @return boolean True on success, false on fail
1562 * (i.e. if the database/model does not support transactions,
1563 * or a transaction has not started).
1564 */
1565        function commit(&$model) {
1566                if (parent::commit($model) && $this->execute($this->_commands['commit'])) {
1567                        $this->_transactionStarted = false;
1568                        return true;
1569                }
1570                return false;
1571        }
1572/**
1573 * Rollback a transaction
1574 *
1575 * @param model $model
1576 * @return boolean True on success, false on fail
1577 * (i.e. if the database/model does not support transactions,
1578 * or a transaction has not started).
1579 */
1580        function rollback(&$model) {
1581                if (parent::rollback($model) && $this->execute($this->_commands['rollback'])) {
1582                        $this->_transactionStarted = false;
1583                        return true;
1584                }
1585                return false;
1586        }
1587/**
1588 * Creates a default set of conditions from the model if $conditions is null/empty.
1589 *
1590 * @param object $model
1591 * @param mixed  $conditions
1592 * @param boolean $useAlias Use model aliases rather than table names when generating conditions
1593 * @return mixed
1594 */
1595        function defaultConditions(&$model, $conditions, $useAlias = true) {
1596                if (!empty($conditions)) {
1597                        return $conditions;
1598                }
1599                if (!$model->exists()) {
1600                        return false;
1601                }
1602                $alias = $model->alias;
1603
1604                if (!$useAlias) {
1605                        $alias = $this->fullTableName($model, false);
1606                }
1607                return array("{$alias}.{$model->primaryKey}" => $model->getID());
1608        }
1609/**
1610 * Returns a key formatted like a string Model.fieldname(i.e. Post.title, or Country.name)
1611 *
1612 * @param unknown_type $model
1613 * @param unknown_type $key
1614 * @param unknown_type $assoc
1615 * @return string
1616 */
1617        function resolveKey($model, $key, $assoc = null) {
1618                if (empty($assoc)) {
1619                        $assoc = $model->alias;
1620                }
1621                if (!strpos('.', $key)) {
1622                        return $this->name($model->alias) . '.' . $this->name($key);
1623                }
1624                return $key;
1625        }
1626/**
1627 * Private helper method to remove query metadata in given data array.
1628 *
1629 * @param array $data
1630 * @return array
1631 */
1632        function __scrubQueryData($data) {
1633                foreach (array('conditions', 'fields', 'joins', 'order', 'limit', 'offset', 'group') as $key) {
1634                        if (!isset($data[$key]) || empty($data[$key])) {
1635                                $data[$key] = array();
1636                        }
1637                }
1638                return $data;
1639        }
1640/**
1641 * Generates the fields list of an SQL query.
1642 *
1643 * @param Model $model
1644 * @param string $alias Alias tablename
1645 * @param mixed $fields
1646 * @param boolean $quote If false, returns fields array unquoted
1647 * @return array
1648 */
1649        function fields(&$model, $alias = null, $fields = array(), $quote = true) {
1650                if (empty($alias)) {
1651                        $alias = $model->alias;
1652                }
1653                if (empty($fields)) {
1654                        $fields = array_keys($model->schema());
1655                } elseif (!is_array($fields)) {
1656                        $fields = String::tokenize($fields);
1657                }
1658                $fields = array_values(array_filter($fields));
1659
1660                if (!$quote) {
1661                        return $fields;
1662                }
1663                $count = count($fields);
1664
1665                if ($count >= 1 && !in_array($fields[0], array('*', 'COUNT(*)'))) {
1666                        for ($i = 0; $i < $count; $i++) {
1667                                if (!preg_match('/^.+\\(.*\\)/', $fields[$i])) {
1668                                        $prepend = '';
1669
1670                                        if (strpos($fields[$i], 'DISTINCT') !== false) {
1671                                                $prepend = 'DISTINCT ';
1672                                                $fields[$i] = trim(str_replace('DISTINCT', '', $fields[$i]));
1673                                        }
1674                                        $dot = strpos($fields[$i], '.');
1675
1676                                        if ($dot === false) {
1677                                                $fields[$i] = $this->name($alias . '.' . $fields[$i]);
1678                                        } else {
1679                                                $value = array();
1680                                                $comma = strpos($fields[$i], ',');
1681                                                if ($comma === false) {
1682                                                        $build = explode('.', $fields[$i]);
1683                                                        if (!Set::numeric($build)) {
1684                                                                $fields[$i] = $this->name($build[0] . '.' . $build[1]);
1685                                                        }
1686                                                        $comma = String::tokenize($fields[$i]);
1687                                                        foreach ($comma as $string) {
1688                                                                if (preg_match('/^[0-9]+\.[0-9]+$/', $string)) {
1689                                                                        $value[] = $string;
1690                                                                } else {
1691                                                                        $build = explode('.', $string);
1692                                                                        $value[] = $this->name(trim($build[0]) . '.' . trim($build[1]));
1693                                                                }
1694                                                        }
1695                                                        $fields[$i] = implode(', ', $value);
1696                                                }
1697                                        }
1698                                        $fields[$i] = $prepend . $fields[$i];
1699                                } elseif (preg_match('/\(([\.\w]+)\)/', $fields[$i], $field)) {
1700                                        if (isset($field[1])) {
1701                                                if (strpos($field[1], '.') === false) {
1702                                                        $field[1] = $this->name($alias . '.' . $field[1]);
1703                                                } else {
1704                                                        $field[0] = explode('.', $field[1]);
1705                                                        if (!Set::numeric($field[0])) {
1706                                                                $field[0] = join('.', array_map(array($this, 'name'), $field[0]));
1707                                                                $fields[$i] = preg_replace('/\(' . $field[1] . '\)/', '(' . $field[0] . ')', $fields[$i], 1);
1708                                                        }
1709                                                }
1710                                        }
1711                                }
1712                        }
1713                }
1714                return array_unique($fields);
1715        }
1716/**
1717 * Creates a WHERE clause by parsing given conditions data.
1718 *
1719 * @param mixed $conditions Array or string of conditions
1720 * @param boolean $quoteValues If true, values should be quoted
1721 * @param boolean $where If true, "WHERE " will be prepended to the return value
1722 * @param Model $model A reference to the Model instance making the query
1723 * @return string SQL fragment
1724 */
1725        function conditions($conditions, $quoteValues = true, $where = true, $model = null) {
1726                $clause = $out = '';
1727
1728                if ($where) {
1729                        $clause = ' WHERE ';
1730                }
1731
1732                if (is_array($conditions) && !empty($conditions)) {
1733                        $out = $this->conditionKeysToString($conditions, $quoteValues, $model);
1734
1735                        if (empty($out)) {
1736                                return $clause . ' 1 = 1';
1737                        }
1738                        return $clause . join(' AND ', $out);
1739                }
1740
1741                if (empty($conditions) || trim($conditions) == '' || $conditions === true) {
1742                        return $clause . '1 = 1';
1743                }
1744                $clauses = '/^WHERE\\x20|^GROUP\\x20BY\\x20|^HAVING\\x20|^ORDER\\x20BY\\x20/i';
1745
1746                if (preg_match($clauses, $conditions, $match)) {
1747                        $clause = '';
1748                }
1749                if (trim($conditions) == '') {
1750                        $conditions = ' 1 = 1';
1751                } else {
1752                        $conditions = $this->__quoteFields($conditions);
1753                }
1754                return $clause . $conditions;
1755        }
1756/**
1757 * Creates a WHERE clause by parsing given conditions array.  Used by DboSource::conditions().
1758 *
1759 * @param array $conditions Array or string of conditions
1760 * @param boolean $quoteValues If true, values should be quoted
1761 * @param Model $model A reference to the Model instance making the query
1762 * @return string SQL fragment
1763 */
1764        function conditionKeysToString($conditions, $quoteValues = true, $model = null) {
1765                $c = 0;
1766                $out = array();
1767                $data = $columnType = null;
1768                $bool = array('and', 'or', 'not', 'and not', 'or not', 'xor', '||', '&&');
1769
1770                foreach ($conditions as $key => $value) {
1771                        $join = ' AND ';
1772                        $not = null;
1773
1774                        if (is_array($value)) {
1775                                $valueInsert = (
1776                                        !empty($value) &&
1777                                        (substr_count($key, '?') == count($value) || substr_count($key, ':') == count($value))
1778                                );
1779                        }
1780
1781                        if (is_numeric($key) && empty($value)) {
1782                                continue;
1783                        } elseif (is_numeric($key) && is_string($value)) {
1784                                $out[] = $not . $this->__quoteFields($value);
1785                        } elseif ((is_numeric($key) && is_array($value)) || in_array(strtolower(trim($key)), $bool)) {
1786                                if (in_array(strtolower(trim($key)), $bool)) {
1787                                        $join = ' ' . strtoupper($key) . ' ';
1788                                } else {
1789                                        $key = $join;
1790                                }
1791                                $value = $this->conditionKeysToString($value, $quoteValues, $model);
1792
1793                                if (strpos($join, 'NOT') !== false) {
1794                                        if (strtoupper(trim($key)) == 'NOT') {
1795                                                $key = 'AND ' . trim($key);
1796                                        }
1797                                        $not = 'NOT ';
1798                                }
1799
1800                                if (empty($value[1])) {
1801                                        if ($not) {
1802                                                $out[] = $not . '(' . $value[0] . ')';
1803                                        } else {
1804                                                $out[] = $value[0] ;
1805                                        }
1806                                } else {
1807                                        $out[] = '(' . $not . '(' . join(') ' . strtoupper($key) . ' (', $value) . '))';
1808                                }
1809
1810                        } else {
1811                                if (is_object($value) && isset($value->type)) {
1812                                        if ($value->type == 'identifier') {
1813                                                $data .= $this->name($key) . ' = ' . $this->name($value->value);
1814                                        } elseif ($value->type == 'expression') {
1815                                                if (is_numeric($key)) {
1816                                                        $data .= $value->value;
1817                                                } else {
1818                                                        $data .= $this->name($key) . ' = ' . $value->value;
1819                                                }
1820                                        }
1821                                } elseif (is_array($value) && !empty($value) && !$valueInsert) {
1822                                        $keys = array_keys($value);
1823                                        if (array_keys($value) === array_values(array_keys($value))) {
1824                                                $count = count($value);
1825                                                if ($count === 1) {
1826                                                        $data = $this->name($key) . ' = (';
1827                                                } else
1828                                                        $data = $this->name($key) . ' IN (';
1829                                                if ($quoteValues || strpos($value[0], '-!') !== 0) {
1830                                                        if (is_object($model)) {
1831                                                                $columnType = $model->getColumnType($key);
1832                                                        }
1833                                                        $data .= join(', ', $this->value($value, $columnType));
1834                                                }
1835                                                $data .= ')';
1836                                        } else {
1837                                                $ret = $this->conditionKeysToString($value, $quoteValues, $model);
1838                                                if (count($ret) > 1) {
1839                                                        $data = '(' . join(') AND (', $ret) . ')';
1840                                                } elseif (isset($ret[0])) {
1841                                                        $data = $ret[0];
1842                                                }
1843                                        }
1844                                } elseif (is_numeric($key) && !empty($value)) {
1845                                        $data = $this->__quoteFields($value);
1846                                } else {
1847                                        $data = $this->__parseKey($model, trim($key), $value);
1848                                }
1849
1850                                if ($data != null) {
1851                                        if (preg_match('/^\(\(\((.+)\)\)\)$/', $data)) {
1852                                                $data = substr($data, 1, strlen($data) - 2);
1853                                        }
1854                                        $out[] = $data;
1855                                        $data = null;
1856                                }
1857                        }
1858                        $c++;
1859                }
1860                return $out;
1861        }
1862/**
1863 * Extracts a Model.field identifier and an SQL condition operator from a string, formats
1864 * and inserts values, and composes them into an SQL snippet.
1865 *
1866 * @param Model $model Model object initiating the query
1867 * @param string $key An SQL key snippet containing a field and optional SQL operator
1868 * @param mixed $value The value(s) to be inserted in the string
1869 * @return string
1870 * @access private
1871 */
1872        function __parseKey($model, $key, $value) {
1873                $operatorMatch = '/^((' . join(')|(', $this->__sqlOps);
1874                $operatorMatch .= '\\x20)|<[>=]?(?![^>]+>)\\x20?|[>=!]{1,3}(?!<)\\x20?)/is';
1875                $bound = (strpos($key, '?') !== false || (is_array($value) && strpos($key, ':') !== false));
1876
1877                if (!strpos($key, ' ')) {
1878                        $operator = '=';
1879                } else {
1880                        list($key, $operator) = explode(' ', trim($key), 2);
1881
1882                        if (!preg_match($operatorMatch, trim($operator)) && strpos($operator, ' ') !== false) {
1883                                $key = $key . ' ' . $operator;
1884                                $split = strrpos($key, ' ');
1885                                $operator = substr($key, $split);
1886                                $key = substr($key, 0, $split);
1887                        }
1888                }
1889                $type = (is_object($model) ? $model->getColumnType($key) : null);
1890                $null = ($value === null || (is_array($value) && empty($value)));
1891
1892                if (strtolower($operator) === 'not') {
1893                        $data = $this->conditionKeysToString(
1894                                array($operator => array($key => $value)), true, $model
1895                        );
1896                        return $data[0];
1897                }
1898                $value = $this->value($value, $type);
1899
1900                $key = (strpos($key, '(') !== false || strpos($key, ')') !== false) ?
1901                        $this->__quoteFields($key) :
1902                        $key = $this->name($key);
1903
1904                if ($bound) {
1905                        return String::insert($key . ' ' . trim($operator), $value);
1906                }
1907
1908                if (!preg_match($operatorMatch, trim($operator))) {
1909                        $operator .= ' =';
1910                }
1911                $operator = trim($operator);
1912
1913                if (is_array($value)) {
1914                        $value = join(', ', $value);
1915
1916                        switch ($operator) {
1917                                case '=':
1918                                        $operator = 'IN';
1919                                break;
1920                                case '!=':
1921                                case '<>':
1922                                        $operator = 'NOT IN';
1923                                break;
1924                        }
1925                        $value = "({$value})";
1926                } elseif ($null) {
1927                        switch ($operator) {
1928                                case '=':
1929                                        $operator = 'IS';
1930                                break;
1931                                case '!=':
1932                                case '<>':
1933                                        $operator = 'IS NOT';
1934                                break;
1935                        }
1936                }
1937                return "{$key} {$operator} {$value}";
1938        }
1939/**
1940 * Quotes Model.fields
1941 *
1942 * @param string $conditions
1943 * @return string or false if no match
1944 * @access private
1945 */
1946        function __quoteFields($conditions) {
1947                $start = $end  = null;
1948                $original = $conditions;
1949
1950                if (!empty($this->startQuote)) {
1951                        $start = preg_quote($this->startQuote);
1952                }
1953                if (!empty($this->endQuote)) {
1954                        $end = preg_quote($this->endQuote);
1955                }
1956                $conditions = str_replace(array($start, $end), '', $conditions);
1957                preg_match_all('/(?:[\'\"][^\'\"\\\]*(?:\\\.[^\'\"\\\]*)*[\'\"])|([a-z0-9_' . $start . $end . ']*\\.[a-z0-9_' . $start . $end . ']*)/i', $conditions, $replace, PREG_PATTERN_ORDER);
1958
1959                if (isset($replace['1']['0'])) {
1960                        $pregCount = count($replace['1']);
1961
1962                        for ($i = 0; $i < $pregCount; $i++) {
1963                                if (!empty($replace['1'][$i]) && !is_numeric($replace['1'][$i])) {
1964                                        $conditions = preg_replace('/\b' . preg_quote($replace['1'][$i]) . '\b/', $this->name($replace['1'][$i]), $conditions);
1965                                }
1966                        }
1967                        return $conditions;
1968                }
1969                return $original;
1970        }
1971/**
1972 * Returns a limit statement in the correct format for the particular database.
1973 *
1974 * @param integer $limit Limit of results returned
1975 * @param integer $offset Offset from which to start results
1976 * @return string SQL limit/offset statement
1977 */
1978        function limit($limit, $offset = null) {
1979                if ($limit) {
1980                        $rt = '';
1981                        if (!strpos(strtolower($limit), 'limit') || strpos(strtolower($limit), 'limit') === 0) {
1982                                $rt = ' LIMIT';
1983                        }
1984
1985                        if ($offset) {
1986                                $rt .= ' ' . $offset . ',';
1987                        }
1988
1989                        $rt .= ' ' . $limit;
1990                        return $rt;
1991                }
1992                return null;
1993        }
1994/**
1995 * Returns an ORDER BY clause as a string.
1996 *
1997 * @param string $key Field reference, as a key (i.e. Post.title)
1998 * @param string $direction Direction (ASC or DESC)
1999 * @return string ORDER BY clause
2000 */
2001        function order($keys, $direction = 'ASC') {
2002                if (is_string($keys) && strpos($keys, ',') && !preg_match('/\(.+\,.+\)/', $keys)) {
2003                        $keys = array_map('trim', explode(',', $keys));
2004                }
2005
2006                if (is_array($keys)) {
2007                        $keys = array_filter($keys);
2008                }
2009
2010                if (empty($keys) || (is_array($keys) && count($keys) && isset($keys[0]) && empty($keys[0]))) {
2011                        return '';
2012                }
2013
2014                if (is_array($keys)) {
2015                        $keys = (Set::countDim($keys) > 1) ? array_map(array(&$this, 'order'), $keys) : $keys;
2016
2017                        foreach ($keys as $key => $value) {
2018                                if (is_numeric($key)) {
2019                                        $key = $value = ltrim(str_replace('ORDER BY ', '', $this->order($value)));
2020                                        $value = (!preg_match('/\\x20ASC|\\x20DESC/i', $key) ? ' ' . $direction : '');
2021                                } else {
2022                                        $value = ' ' . $value;
2023                                }
2024
2025                                if (!preg_match('/^.+\\(.*\\)/', $key) && !strpos($key, ',')) {
2026                                        if (preg_match('/\\x20ASC|\\x20DESC/i', $key, $dir)) {
2027                                                $dir = $dir[0];
2028                                                $key = preg_replace('/\\x20ASC|\\x20DESC/i', '', $key);
2029                                        } else {
2030                                                $dir = '';
2031                                        }
2032                                        $key = trim($key);
2033                                        if (!preg_match('/\s/', $key)) {
2034                                                $key = $this->name($key);
2035                                        }
2036                                        $key .= ' ' . trim($dir);
2037                                }
2038                                $order[] = $this->order($key . $value);
2039                        }
2040                        return ' ORDER BY ' . trim(str_replace('ORDER BY', '', join(',', $order)));
2041                }
2042                $keys = preg_replace('/ORDER\\x20BY/i', '', $keys);
2043
2044                if (strpos($keys, '.')) {
2045                        preg_match_all('/([a-zA-Z0-9_]{1,})\\.([a-zA-Z0-9_]{1,})/', $keys, $result, PREG_PATTERN_ORDER);
2046                        $pregCount = count($result[0]);
2047
2048                        for ($i = 0; $i < $pregCount; $i++) {
2049                                if (!is_numeric($result[0][$i])) {
2050                                        $keys = preg_replace('/' . $result[0][$i] . '/', $this->name($result[0][$i]), $keys);
2051                                }
2052                        }
2053                        $result = ' ORDER BY ' . $keys;
2054                        return $result . (!preg_match('/\\x20ASC|\\x20DESC/i', $keys) ? ' ' . $direction : '');
2055
2056                } elseif (preg_match('/(\\x20ASC|\\x20DESC)/i', $keys, $match)) {
2057                        $direction = $match[1];
2058                        return ' ORDER BY ' . preg_replace('/' . $match[1] . '/', '', $keys) . $direction;
2059                }
2060                return ' ORDER BY ' . $keys . ' ' . $direction;
2061        }
2062/**
2063 * Create a GROUP BY SQL clause
2064 *
2065 * @param string $group Group By Condition
2066 * @return mixed string condition or null
2067 */
2068        function group($group) {
2069                if ($group) {
2070                        if (is_array($group)) {
2071                                $group = join(', ', $group);
2072                        }
2073                        return ' GROUP BY ' . $this->__quoteFields($group);
2074                }
2075                return null;
2076        }
2077/**
2078 * Disconnects database, kills the connection and says the connection is closed,
2079 * and if DEBUG is turned on, the log for this object is shown.
2080 *
2081 */
2082        function close() {
2083                if (Configure::read() > 1) {
2084                        $this->showLog();
2085                }
2086                $this->disconnect();
2087        }
2088/**
2089 * Checks if the specified table contains any record matching specified SQL
2090 *
2091 * @param Model $model Model to search
2092 * @param string $sql SQL WHERE clause (condition only, not the "WHERE" part)
2093 * @return boolean True if the table has a matching record, else false
2094 */
2095        function hasAny(&$Model, $sql) {
2096                $sql = $this->conditions($sql);
2097                $table = $this->fullTableName($Model);
2098                $where = $sql ? "WHERE {$sql}" : 'WHERE 1 = 1';
2099                $id = $Model->primaryKey;
2100
2101                $out = $this->fetchRow("SELECT COUNT({$id}) {$this->alias}count FROM {$table} {$where}");
2102
2103                if (is_array($out)) {
2104                        return $out[0]['count'];
2105                }
2106                return false;
2107        }
2108/**
2109 * Gets the length of a database-native column description, or null if no length
2110 *
2111 * @param string $real Real database-layer column type (i.e. "varchar(255)")
2112 * @return mixed An integer or string representing the length of the column
2113 */
2114        function length($real) {
2115                if (!preg_match_all('/([\w\s]+)(?:\((\d+)(?:,(\d+))?\))?(\sunsigned)?(\szerofill)?/', $real, $result)) {
2116                        trigger_error(__('FIXME: Can\'t parse field: ' . $real, true), E_USER_WARNING);
2117                        $col = str_replace(array(')', 'unsigned'), '', $real);
2118                        $limit = null;
2119
2120                        if (strpos($col, '(') !== false) {
2121                                list($col, $limit) = explode('(', $col);
2122                        }
2123                        if ($limit != null) {
2124                                return intval($limit);
2125                        }
2126                        return null;
2127                }
2128
2129                $types = array(
2130                        'int' => 1, 'tinyint' => 1, 'smallint' => 1, 'mediumint' => 1, 'integer' => 1, 'bigint' => 1
2131                );
2132
2133                list($real, $type, $length, $offset, $sign, $zerofill) = $result;
2134                $typeArr = $type;
2135                $type = $type[0];
2136                $length = $length[0];
2137                $offset = $offset[0];
2138
2139                $isFloat = in_array($type, array('dec', 'decimal', 'float', 'numeric', 'double'));
2140                if ($isFloat && $offset) {
2141                        return $length.','.$offset;
2142                }
2143
2144                if (($real[0] == $type) && (count($real) == 1)) {
2145                        return null;
2146                }
2147
2148                if (isset($types[$type])) {
2149                        $length += $types[$type];
2150                        if (!empty($sign)) {
2151                                $length--;
2152                        }
2153                } elseif (in_array($type, array('enum', 'set'))) {
2154                        $length = 0;
2155                        foreach ($typeArr as $key => $enumValue) {
2156                                if ($key == 0) {
2157                                        continue;
2158                                }
2159                                $tmpLength = strlen($enumValue);
2160                                if ($tmpLength > $length) {
2161                                        $length = $tmpLength;
2162                                }
2163                        }
2164                }
2165                return intval($length);
2166        }
2167/**
2168 * Translates between PHP boolean values and Database (faked) boolean values
2169 *
2170 * @param mixed $data Value to be translated
2171 * @return mixed Converted boolean value
2172 */
2173        function boolean($data) {
2174                if ($data === true || $data === false) {
2175                        if ($data === true) {
2176                                return 1;
2177                        }
2178                        return 0;
2179                } else {
2180                        return !empty($data);
2181                }
2182        }
2183/**
2184 * Inserts multiple values into a table
2185 *
2186 * @param string $table
2187 * @param string $fields
2188 * @param array $values
2189 * @access protected
2190 */
2191        function insertMulti($table, $fields, $values) {
2192                $table = $this->fullTableName($table);
2193                if (is_array($fields)) {
2194                        $fields = join(', ', array_map(array(&$this, 'name'), $fields));
2195                }
2196                $count = count($values);
2197                for ($x = 0; $x < $count; $x++) {
2198                        $this->query("INSERT INTO {$table} ({$fields}) VALUES {$values[$x]}");
2199                }
2200        }
2201/**
2202 * Returns an array of the indexes in given datasource name.
2203 *
2204 * @param string $model Name of model to inspect
2205 * @return array Fields in table. Keys are column and unique
2206 */
2207        function index($model) {
2208                return false;
2209        }
2210/**
2211 * Generate a database-native schema for the given Schema object
2212 *
2213 * @param object $schema An instance of a subclass of CakeSchema
2214 * @param string $tableName Optional.  If specified only the table name given will be generated.
2215 *                                              Otherwise, all tables defined in the schema are generated.
2216 * @return string
2217 */
2218        function createSchema($schema, $tableName = null) {
2219                if (!is_a($schema, 'CakeSchema')) {
2220                        trigger_error(__('Invalid schema object', true), E_USER_WARNING);
2221                        return null;
2222                }
2223                $out = '';
2224
2225                foreach ($schema->tables as $curTable => $columns) {
2226                        if (!$tableName || $tableName == $curTable) {
2227                                $cols = $colList = $indexes = array();
2228                                $primary = null;
2229                                $table = $this->fullTableName($curTable);
2230
2231                                foreach ($columns as $name => $col) {
2232                                        if (is_string($col)) {
2233                                                $col = array('type' => $col);
2234                                        }
2235                                        if (isset($col['key']) && $col['key'] == 'primary') {
2236                                                $primary = $name;
2237                                        }
2238                                        if ($name !== 'indexes') {
2239                                                $col['name'] = $name;
2240                                                if (!isset($col['type'])) {
2241                                                        $col['type'] = 'string';
2242                                                }
2243                                                $cols[] = $this->buildColumn($col);
2244                                        } else {
2245                                                $indexes = array_merge($indexes, $this->buildIndex($col, $table));
2246                                        }
2247                                }
2248                                if (empty($indexes) && !empty($primary)) {
2249                                        $col = array('PRIMARY' => array('column' => $primary, 'unique' => 1));
2250                                        $indexes = array_merge($indexes, $this->buildIndex($col, $table));
2251                                }
2252                                $columns = $cols;
2253                                $out .= $this->renderStatement('schema', compact('table', 'columns', 'indexes')) . "\n\n";
2254                        }
2255                }
2256                return $out;
2257        }
2258/**
2259 * Generate a alter syntax from  CakeSchema::compare()
2260 *
2261 * @param unknown_type $schema
2262 * @return unknown
2263 */
2264        function alterSchema($compare, $table = null) {
2265                return false;
2266        }
2267/**
2268 * Generate a "drop table" statement for the given Schema object
2269 *
2270 * @param object $schema An instance of a subclass of CakeSchema
2271 * @param string $table Optional.  If specified only the table name given will be generated.
2272 *                                              Otherwise, all tables defined in the schema are generated.
2273 * @return string
2274 */
2275        function dropSchema($schema, $table = null) {
2276                if (!is_a($schema, 'CakeSchema')) {
2277                        trigger_error(__('Invalid schema object', true), E_USER_WARNING);
2278                        return null;
2279                }
2280                $out = '';
2281
2282                foreach ($schema->tables as $curTable => $columns) {
2283                        if (!$table || $table == $curTable) {
2284                                $out .= 'DROP TABLE ' . $this->fullTableName($curTable) . ";\n";
2285                        }
2286                }
2287                return $out;
2288        }
2289/**
2290 * Generate a database-native column schema string
2291 *
2292 * @param array $column An array structured like the following: array('name'=>'value', 'type'=>'value'[, options]),
2293 *                                              where options can be 'default', 'length', or 'key'.
2294 * @return string
2295 */
2296        function buildColumn($column) {
2297                $name = $type = null;
2298                extract(array_merge(array('null' => true), $column));
2299
2300                if (empty($name) || empty($type)) {
2301                        trigger_error('Column name or type not defined in schema', E_USER_WARNING);
2302                        return null;
2303                }
2304
2305                if (!isset($this->columns[$type])) {
2306                        trigger_error("Column type {$type} does not exist", E_USER_WARNING);
2307                        return null;
2308                }
2309
2310                $real = $this->columns[$type];
2311                $out = $this->name($name) . ' ' . $real['name'];
2312
2313                if (isset($real['limit']) || isset($real['length']) || isset($column['limit']) || isset($column['length'])) {
2314                        if (isset($column['length'])) {
2315                                $length = $column['length'];
2316                        } elseif (isset($column['limit'])) {
2317                                $length = $column['limit'];
2318                        } elseif (isset($real['length'])) {
2319                                $length = $real['length'];
2320                        } else {
2321                                $length = $real['limit'];
2322                        }
2323                        $out .= '(' . $length . ')';
2324                }
2325
2326                if (($column['type'] == 'integer' || $column['type'] == 'float' ) && isset($column['default']) && $column['default'] === '') {
2327                        $column['default'] = null;
2328                }
2329
2330                if (isset($column['key']) && $column['key'] == 'primary' && $type == 'integer') {
2331                        $out .= ' ' . $this->columns['primary_key']['name'];
2332                } elseif (isset($column['key']) && $column['key'] == 'primary') {
2333                        $out .= ' NOT NULL';
2334                } elseif (isset($column['default']) && isset($column['null']) && $column['null'] == false) {
2335                        $out .= ' DEFAULT ' . $this->value($column['default'], $type) . ' NOT NULL';
2336                } elseif (isset($column['default'])) {
2337                        $out .= ' DEFAULT ' . $this->value($column['default'], $type);
2338                } elseif (isset($column['null']) && $column['null'] == true) {
2339                        $out .= ' DEFAULT NULL';
2340                } elseif (isset($column['null']) && $column['null'] == false) {
2341                        $out .= ' NOT NULL';
2342                }
2343                return $out;
2344        }
2345/**
2346 * Format indexes for create table
2347 *
2348 * @param array $indexes
2349 * @param string $table
2350 * @return array
2351 */
2352        function buildIndex($indexes, $table = null) {
2353                $join = array();
2354                foreach ($indexes as $name => $value) {
2355                        $out = '';
2356                        if ($name == 'PRIMARY') {
2357                                $out .= 'PRIMARY ';
2358                                $name = null;
2359                        } else {
2360                                if (!empty($value['unique'])) {
2361                                        $out .= 'UNIQUE ';
2362                                }
2363                        }
2364                        if (is_array($value['column'])) {
2365                                $out .= 'KEY '. $name .' (' . join(', ', array_map(array(&$this, 'name'), $value['column'])) . ')';
2366                        } else {
2367                                $out .= 'KEY '. $name .' (' . $this->name($value['column']) . ')';
2368                        }
2369                        $join[] = $out;
2370                }
2371                return $join;
2372        }
2373/**
2374 * Guesses the data type of an array
2375 *
2376 * @param string $value
2377 * @return void
2378 * @access public
2379 */
2380        function introspectType($value) {
2381                if (!is_array($value)) {
2382                        if ($value === true || $value === false) {
2383                                return 'boolean';
2384                        }
2385                        if (is_float($value) && floatval($value) === $value) {
2386                                return 'float';
2387                        }
2388                        if (is_int($value) && intval($value) === $value) {
2389                                return 'integer';
2390                        }
2391                        if (is_string($value) && strlen($value) > 255) {
2392                                return 'text';
2393                        }
2394                        return 'string';
2395                }
2396
2397                $isAllFloat = $isAllInt = true;
2398                $containsFloat = $containsInt = $containsString = false;
2399                foreach ($value as $key => $valElement) {
2400                        $valElement = trim($valElement);
2401                        if (!is_float($valElement) && !preg_match('/^[\d]+\.[\d]+$/', $valElement)) {
2402                                $isAllFloat = false;
2403                        } else {
2404                                $containsFloat = true;
2405                                continue;
2406                        }
2407                        if (!is_int($valElement) && !preg_match('/^[\d]+$/', $valElement)) {
2408                                $isAllInt = false;
2409                        } else {
2410                                $containsInt = true;
2411                                continue;
2412                        }
2413                        $containsString = true;
2414                }
2415
2416                if ($isAllFloat) {
2417                        return 'float';
2418                }
2419                if ($isAllInt) {
2420                        return 'integer';
2421                }
2422
2423                if ($containsInt && !$containsString) {
2424                        return 'integer';
2425                }
2426                return 'string';
2427        }
2428}
2429?>
Note: See TracBrowser for help on using the repository browser.