ActiveQuery.php 9.93 KB
Newer Older
1 2 3 4 5 6 7 8 9
<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\sphinx;

10
use yii\base\InvalidCallException;
11 12
use yii\db\ActiveQueryInterface;
use yii\db\ActiveQueryTrait;
13
use yii\db\ActiveRelationTrait;
14

15
/**
16 17
 * ActiveQuery represents a Sphinx query associated with an Active Record class.
 *
18 19
 * An ActiveQuery can be a normal query or be used in a relational context.
 *
20
 * ActiveQuery instances are usually created by [[ActiveRecord::find()]] and [[ActiveRecord::findBySql()]].
21 22 23 24
 * Relational queries are created by [[ActiveRecord::hasOne()]] and [[ActiveRecord::hasMany()]].
 *
 * Normal Query
 * ------------
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
 *
 * Because ActiveQuery extends from [[Query]], one can use query methods, such as [[where()]],
 * [[orderBy()]] to customize the query options.
 *
 * ActiveQuery also provides the following additional query options:
 *
 * - [[with()]]: list of relations that this query should be performed with.
 * - [[indexBy()]]: the name of the column by which the query result should be indexed.
 * - [[asArray()]]: whether to return each record as an array.
 *
 * These options can be configured using methods of the same name. For example:
 *
 * ~~~
 * $articles = Article::find()->with('source')->asArray()->all();
 * ~~~
 *
 * ActiveQuery allows to build the snippets using sources provided by ActiveRecord.
 * You can use [[snippetByModel()]] method to enable this.
 * For example:
 *
 * ~~~
 * class Article extends ActiveRecord
 * {
 *     public function getSource()
 *     {
 *         return $this->hasOne('db', ArticleDb::className(), ['id' => 'id']);
 *     }
 *
 *     public function getSnippetSource()
 *     {
 *         return $this->source->content;
 *     }
 *
 *     ...
 * }
 *
 * $articles = Article::find()->with('source')->snippetByModel()->all();
 * ~~~
63
 *
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
 * Relational query
 * ----------------
 *
 * In relational context ActiveQuery represents a relation between two Active Record classes.
 *
 * Relational ActiveQuery instances are usually created by calling [[ActiveRecord::hasOne()]] and
 * [[ActiveRecord::hasMany()]]. An Active Record class declares a relation by defining
 * a getter method which calls one of the above methods and returns the created ActiveQuery object.
 *
 * A relation is specified by [[link]] which represents the association between columns
 * of different tables; and the multiplicity of the relation is indicated by [[multiple]].
 *
 * If a relation involves a pivot table, it may be specified by [[via()]].
 * This methods may only be called in a relational context. Same is true for [[inverseOf()]], which
 * marks a relation as inverse of another relation.
 *
80 81 82
 * @author Paul Klimov <klimov.paul@gmail.com>
 * @since 2.0
 */
83
class ActiveQuery extends Query implements ActiveQueryInterface
84
{
85 86
    use ActiveQueryTrait;
    use ActiveRelationTrait;
87

88 89 90 91 92
    /**
     * @event Event an event that is triggered when the query is initialized via [[init()]].
     */
    const EVENT_INIT = 'init';

93 94 95 96 97
    /**
     * @var string the SQL statement to be executed for retrieving AR records.
     * This is set by [[ActiveRecord::findBySql()]].
     */
    public $sql;
98

Qiang Xue committed
99 100 101 102 103 104 105 106 107 108 109

    /**
     * Constructor.
     * @param array $modelClass the model class associated with this query
     * @param array $config configurations to be applied to the newly created query object
     */
    public function __construct($modelClass, $config = [])
    {
        $this->modelClass = $modelClass;
        parent::__construct($config);
    }
110 111 112 113 114 115 116 117 118 119 120 121

    /**
     * Initializes the object.
     * This method is called at the end of the constructor. The default implementation will trigger
     * an [[EVENT_INIT]] event. If you override this method, make sure you call the parent implementation at the end
     * to ensure triggering of the event.
     */
    public function init()
    {
        parent::init();
        $this->trigger(self::EVENT_INIT);
    }
Qiang Xue committed
122

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
    /**
     * Sets the [[snippetCallback]] to [[fetchSnippetSourceFromModels()]], which allows to
     * fetch the snippet source strings from the Active Record models, using method
     * [[ActiveRecord::getSnippetSource()]].
     * For example:
     *
     * ~~~
     * class Article extends ActiveRecord
     * {
     *     public function getSnippetSource()
     *     {
     *         return file_get_contents('/path/to/source/files/' . $this->id . '.txt');;
     *     }
     * }
     *
     * $articles = Article::find()->snippetByModel()->all();
     * ~~~
     *
     * Warning: this option should NOT be used with [[asArray]] at the same time!
     * @return static the query object itself
     */
    public function snippetByModel()
    {
        $this->snippetCallback([$this, 'fetchSnippetSourceFromModels']);
147

148 149
        return $this;
    }
150

151 152
    /**
     * Executes query and returns all results as an array.
153 154 155
     * @param Connection $db the DB connection used to create the DB command.
     * If null, the DB connection returned by [[modelClass]] will be used.
     * @return array the query results. If the query results in nothing, an empty array will be returned.
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
     */
    public function all($db = null)
    {
        $command = $this->createCommand($db);
        $rows = $command->queryAll();
        if (!empty($rows)) {
            $models = $this->createModels($rows);
            if (!empty($this->with)) {
                $this->findWith($this->with, $models);
            }
            $models = $this->fillUpSnippets($models);
            if (!$this->asArray) {
                foreach ($models as $model) {
                    $model->afterFind();
                }
            }
172

173 174 175 176 177
            return $models;
        } else {
            return [];
        }
    }
178

179 180
    /**
     * Executes query and returns a single row of result.
181 182
     * @param Connection $db the DB connection used to create the DB command.
     * If null, the DB connection returned by [[modelClass]] will be used.
183
     * @return ActiveRecord|array|null a single row of query result. Depending on the setting of [[asArray]],
184 185
     * the query result may be either an array or an ActiveRecord object. Null will be returned
     * if the query results in nothing.
186 187 188 189 190 191 192 193 194
     */
    public function one($db = null)
    {
        $command = $this->createCommand($db);
        $row = $command->queryOne();
        if ($row !== false) {
            if ($this->asArray) {
                $model = $row;
            } else {
195
                /* @var $class ActiveRecord */
196 197 198 199 200 201 202 203 204 205 206 207 208
                $class = $this->modelClass;
                $model = $class::instantiate($row);
                $class::populateRecord($model, $row);
            }
            if (!empty($this->with)) {
                $models = [$model];
                $this->findWith($this->with, $models);
                $model = $models[0];
            }
            list ($model) = $this->fillUpSnippets([$model]);
            if (!$this->asArray) {
                $model->afterFind();
            }
209

210 211 212 213 214
            return $model;
        } else {
            return null;
        }
    }
215

216 217
    /**
     * Creates a DB command that can be used to execute this query.
218 219 220
     * @param Connection $db the DB connection used to create the DB command.
     * If null, the DB connection returned by [[modelClass]] will be used.
     * @return Command the created DB command instance.
221 222 223 224 225 226 227 228 229 230 231
     */
    public function createCommand($db = null)
    {
        if ($this->primaryModel !== null) {
            // lazy loading a relational query
            if ($this->via instanceof self) {
                // via pivot index
                $viaModels = $this->via->findPivotRows([$this->primaryModel]);
                $this->filterByModels($viaModels);
            } elseif (is_array($this->via)) {
                // via relation
232
                /* @var $viaQuery ActiveQuery */
233 234 235 236 237 238 239 240 241 242 243 244 245 246
                list($viaName, $viaQuery) = $this->via;
                if ($viaQuery->multiple) {
                    $viaModels = $viaQuery->all();
                    $this->primaryModel->populateRelation($viaName, $viaModels);
                } else {
                    $model = $viaQuery->one();
                    $this->primaryModel->populateRelation($viaName, $model);
                    $viaModels = $model === null ? [] : [$model];
                }
                $this->filterByModels($viaModels);
            } else {
                $this->filterByModels([$this->primaryModel]);
            }
        }
247

248 249
        $this->setConnection($db);
        $db = $this->getConnection();
250

251
        if ($this->sql === null) {
252 253 254 255
            list ($sql, $params) = $db->getQueryBuilder()->build($this);
        } else {
            $sql = $this->sql;
            $params = $this->params;
256 257
        }

258
        return $db->createCommand($sql, $params);
259 260 261 262 263 264 265 266 267 268 269 270 271 272
    }

    /**
     * @inheritdoc
     */
    protected function defaultConnection()
    {
        $modelClass = $this->modelClass;

        return $modelClass::getDb();
    }

    /**
     * Fetches the source for the snippets using [[ActiveRecord::getSnippetSource()]] method.
273
     * @param ActiveRecord[] $models raw query result rows.
274
     * @throws \yii\base\InvalidCallException if [[asArray]] enabled.
275
     * @return array snippet source strings
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
     */
    protected function fetchSnippetSourceFromModels($models)
    {
        if ($this->asArray) {
            throw new InvalidCallException('"' . __METHOD__ . '" unable to determine snippet source from plain array. Either disable "asArray" option or use regular "snippetCallback"');
        }
        $result = [];
        foreach ($models as $model) {
            $result[] = $model->getSnippetSource();
        }

        return $result;
    }

    /**
     * @inheritdoc
     */
    protected function callSnippets(array $source)
    {
        $from = $this->from;
        if ($from === null) {
297
            /* @var $modelClass ActiveRecord */
298 299 300 301 302 303 304
            $modelClass = $this->modelClass;
            $tableName = $modelClass::indexName();
            $from = [$tableName];
        }

        return $this->callSnippetsInternal($source, $from[0]);
    }
Qiang Xue committed
305
}