ActiveQuery.php 7.95 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
	use ActiveQueryTrait;
86
	use ActiveRelationTrait;
87

88 89 90 91 92 93
	/**
	 * @var string the SQL statement to be executed for retrieving AR records.
	 * This is set by [[ActiveRecord::findBySql()]].
	 */
	public $sql;

94
	/**
95
	 * Sets the [[snippetCallback]] to [[fetchSnippetSourceFromModels()]], which allows to
96 97
	 * fetch the snippet source strings from the Active Record models, using method
	 * [[ActiveRecord::getSnippetSource()]].
98 99 100 101 102 103 104 105 106 107 108 109 110 111
	 * 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();
	 * ~~~
	 *
112 113 114 115 116
	 * Warning: this option should NOT be used with [[asArray]] at the same time!
	 * @return static the query object itself
	 */
	public function snippetByModel()
	{
117
		$this->snippetCallback([$this, 'fetchSnippetSourceFromModels']);
118 119 120
		return $this;
	}

121 122 123 124 125 126 127 128 129 130 131
	/**
	 * Executes query and returns all results as an array.
	 * @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.
	 */
	public function all($db = null)
	{
		$command = $this->createCommand($db);
		$rows = $command->queryAll();
		if (!empty($rows)) {
Carsten Brandt committed
132
			$models = $this->createModels($rows);
133
			if (!empty($this->with)) {
Klimov Paul committed
134
				$this->findWith($this->with, $models);
135
			}
136
			$models = $this->fillUpSnippets($models);
137 138 139 140 141
			if (!$this->asArray) {
				foreach($models as $model) {
					$model->afterFind();
				}
			}
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
			return $models;
		} else {
			return [];
		}
	}

	/**
	 * Executes query and returns a single row of result.
	 * @param Connection $db the DB connection used to create the DB command.
	 * If null, the DB connection returned by [[modelClass]] will be used.
	 * @return ActiveRecord|array|null a single row of query result. Depending on the setting of [[asArray]],
	 * the query result may be either an array or an ActiveRecord object. Null will be returned
	 * if the query results in nothing.
	 */
	public function one($db = null)
	{
		$command = $this->createCommand($db);
		$row = $command->queryOne();
		if ($row !== false) {
			if ($this->asArray) {
				$model = $row;
			} else {
				/** @var $class ActiveRecord */
				$class = $this->modelClass;
166 167
				$model = $class::instantiate($row);
				$class::populateRecord($model, $row);
168
			}
169
			if (!empty($this->with)) {
170
				$models = [$model];
Klimov Paul committed
171
				$this->findWith($this->with, $models);
172
				$model = $models[0];
173
			}
174
			list ($model) = $this->fillUpSnippets([$model]);
175 176 177
			if (!$this->asArray) {
				$model->afterFind();
			}
178 179 180 181 182 183 184 185 186 187 188 189 190 191
			return $model;
		} else {
			return null;
		}
	}

	/**
	 * Creates a DB command that can be used to execute this query.
	 * @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.
	 */
	public function createCommand($db = null)
	{
192 193 194 195 196 197 198 199
		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
200
				/** @var ActiveQuery $viaQuery */
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
				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]);
			}
		}

216 217
		$this->setConnection($db);
		$db = $this->getConnection();
218 219 220 221 222 223 224

		$params = $this->params;
		if ($this->sql === null) {
			list ($this->sql, $params) = $db->getQueryBuilder()->build($this);
		}
		return $db->createCommand($this->sql, $params);
	}
225 226

	/**
Qiang Xue committed
227
	 * @inheritdoc
228 229 230 231 232 233 234 235 236 237
	 */
	protected function defaultConnection()
	{
		$modelClass = $this->modelClass;
		return $modelClass::getDb();
	}

	/**
	 * Fetches the source for the snippets using [[ActiveRecord::getSnippetSource()]] method.
	 * @param ActiveRecord[] $models raw query result rows.
238
	 * @throws \yii\base\InvalidCallException if [[asArray]] enabled.
239 240 241 242
	 * @return array snippet source strings
	 */
	protected function fetchSnippetSourceFromModels($models)
	{
243 244 245
		if ($this->asArray) {
			throw new InvalidCallException('"' . __METHOD__ . '" unable to determine snippet source from plain array. Either disable "asArray" option or use regular "snippetCallback"');
		}
246 247 248 249 250 251
		$result = [];
		foreach ($models as $model) {
			$result[] = $model->getSnippetSource();
		}
		return $result;
	}
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266

	/**
	 * @inheritdoc
	 */
	protected function callSnippets(array $source)
	{
		$from = $this->from;
		if ($from === null) {
			/** @var ActiveRecord $modelClass */
			$modelClass = $this->modelClass;
			$tableName = $modelClass::indexName();
			$from = [$tableName];
		}
		return $this->callSnippetsInternal($source, $from[0]);
	}
Qiang Xue committed
267
}