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

namespace yii\elasticsearch;
Carsten Brandt committed
9

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

/**
15
 * ActiveQuery represents a [[Query]] associated with an [[ActiveRecord]] class.
16
 *
17 18
 * An ActiveQuery can be a normal query or be used in a relational context.
 *
19
 * ActiveQuery instances are usually created by [[ActiveRecord::find()]].
20 21 22 23
 * Relational queries are created by [[ActiveRecord::hasOne()]] and [[ActiveRecord::hasMany()]].
 *
 * Normal Query
 * ------------
24 25 26 27 28 29 30
 *
 * ActiveQuery mainly provides the following methods to retrieve the query results:
 *
 * - [[one()]]: returns a single record populated with the first row of data.
 * - [[all()]]: returns all records based on the query results.
 * - [[count()]]: returns the number of records.
 * - [[scalar()]]: returns the value of the first column in the first row of the query result.
31
 * - [[column()]]: returns the value of the first column in the query result.
32 33
 * - [[exists()]]: returns a value indicating whether the query result has data or not.
 *
34 35
 * Because ActiveQuery extends from [[Query]], one can use query methods, such as [[where()]],
 * [[orderBy()]] to customize the query options.
36 37 38 39 40 41 42 43 44
 *
 * 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:
 *
45
 * ```php
46
 * $customers = Customer::find()->with('orders')->asArray()->all();
47 48 49 50 51 52 53 54 55 56 57 58
 * ```
 * > NOTE: elasticsearch limits the number of records returned to 10 records by default.
 * > If you expect to get more records you should specify limit explicitly.
 *
 * 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.
59
 *
60 61 62 63 64 65 66 67 68 69 70
 * 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.
 *
 * > NOTE: elasticsearch limits the number of records returned by any query to 10 records by default.
 * > If you expect to get more records you should specify limit explicitly in relation definition.
 * > This is also important for relations that use [[via()]] so that if via records are limited to 10
 * > the relations records can also not be more than 10.
71
 *
72 73 74
 * @author Carsten Brandt <mail@cebe.cc>
 * @since 2.0
 */
75
class ActiveQuery extends Query implements ActiveQueryInterface
76
{
77
	use ActiveQueryTrait;
78
	use ActiveRelationTrait;
79 80

	/**
81 82 83 84
	 * 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.
85
	 */
86
	public function createCommand($db = null)
87
	{
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
		if ($this->primaryModel !== null) {
			// lazy loading
			if (is_array($this->via)) {
				// via relation
				/** @var ActiveQuery $viaQuery */
				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]);
			}
		}

108
		/** @var ActiveRecord $modelClass */
109 110 111
		$modelClass = $this->modelClass;
		if ($db === null) {
			$db = $modelClass::getDb();
112 113
		}

114 115 116 117 118 119
		if ($this->type === null) {
			$this->type = $modelClass::type();
		}
		if ($this->index === null) {
			$this->index = $modelClass::index();
			$this->type = $modelClass::type();
120
		}
121 122
		$commandConfig = $db->getQueryBuilder()->build($this);
		return $db->createCommand($commandConfig);
123 124 125
	}

	/**
126 127 128 129
	 * 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.
130
	 */
131
	public function all($db = null)
132
	{
133 134
		$result = $this->createCommand($db)->search();
		if (empty($result['hits']['hits'])) {
135 136
			return [];
		}
137 138 139 140 141 142 143
		if ($this->fields !== null) {
			foreach ($result['hits']['hits'] as &$row) {
				$row['_source'] = isset($row['fields']) ? $row['fields'] : [];
				unset($row['fields']);
			}
			unset($row);
		}
144 145
		/** @var ActiveRecord $modelClass */
		$modelClass = $this->modelClass;
146
		$pk = $modelClass::primaryKey()[0];
147 148
		if ($this->asArray && $this->indexBy) {
			foreach ($result['hits']['hits'] as &$row) {
149 150 151 152
				if ($pk === '_id') {
					$row['_source']['_id'] = $row['_id'];
				}
				$row['_source']['_score'] = $row['_score'];
153 154
				$row = $row['_source'];
			}
155
			unset($row);
156
		}
Carsten Brandt committed
157
		$models = $this->createModels($result['hits']['hits']);
158
		if ($this->asArray && !$this->indexBy) {
AlexGx committed
159
			foreach ($models as $key => $model) {
160 161 162 163
				if ($pk === '_id') {
					$model['_source']['_id'] = $model['_id'];
				}
				$model['_source']['_score'] = $model['_score'];
164 165 166
				$models[$key] = $model['_source'];
			}
		}
167 168
		if (!empty($this->with)) {
			$this->findWith($this->with, $models);
169
		}
170
		if (!$this->asArray) {
AlexGx committed
171
			foreach ($models as $model) {
172 173 174
				$model->afterFind();
			}
		}
175
		return $models;
176 177 178
	}

	/**
179 180 181 182 183 184
	 * 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.
185
	 */
186
	public function one($db = null)
187
	{
Carsten Brandt committed
188
		if (($result = parent::one($db)) === false) {
189 190
			return null;
		}
191
		if ($this->asArray) {
192 193
			/** @var ActiveRecord $modelClass */
			$modelClass = $this->modelClass;
Carsten Brandt committed
194
			$model = $result['_source'];
195
			$pk = $modelClass::primaryKey()[0];
196 197 198 199
			if ($pk === '_id') {
				$model['_id'] = $result['_id'];
			}
			$model['_score'] = $result['_score'];
200 201 202
		} else {
			/** @var ActiveRecord $class */
			$class = $this->modelClass;
203 204
			$model = $class::instantiate($result);
			$class::populateRecord($model, $result);
205 206 207 208 209 210
		}
		if (!empty($this->with)) {
			$models = [$model];
			$this->findWith($this->with, $models);
			$model = $models[0];
		}
211 212 213
		if (!$this->asArray) {
			$model->afterFind();
		}
214
		return $model;
215
	}
216

217
	/**
Qiang Xue committed
218
	 * @inheritdoc
219 220 221 222 223
	 */
	public function search($db = null, $options = [])
	{
		$result = $this->createCommand($db)->search($options);
		if (!empty($result['hits']['hits'])) {
Carsten Brandt committed
224
			$models = $this->createModels($result['hits']['hits']);
225
			if ($this->asArray) {
226 227
				/** @var ActiveRecord $modelClass */
				$modelClass = $this->modelClass;
228
				$pk = $modelClass::primaryKey()[0];
AlexGx committed
229
				foreach ($models as $key => $model) {
230 231 232 233
					if ($pk === '_id') {
						$model['_source']['_id'] = $model['_id'];
					}
					$model['_source']['_score'] = $model['_score'];
234 235 236 237 238 239
					$models[$key] = $model['_source'];
				}
			}
			if (!empty($this->with)) {
				$this->findWith($this->with, $models);
			}
240
			if (!$this->asArray) {
AlexGx committed
241
				foreach ($models as $model) {
242 243 244
					$model->afterFind();
				}
			}
245 246 247 248 249
			$result['hits']['hits'] = $models;
		}
		return $result;
	}

250
	/**
Qiang Xue committed
251
	 * @inheritdoc
252 253 254 255 256
	 */
	public function scalar($field, $db = null)
	{
		$record = parent::one($db);
		if ($record !== false) {
257
			if ($field == '_id') {
258 259 260 261 262 263 264 265 266
				return $record['_id'];
			} elseif (isset($record['_source'][$field])) {
				return $record['_source'][$field];
			}
		}
		return null;
	}

	/**
Qiang Xue committed
267
	 * @inheritdoc
268 269 270
	 */
	public function column($field, $db = null)
	{
271
		if ($field == '_id') {
272 273
			$command = $this->createCommand($db);
			$command->queryParts['fields'] = [];
274 275 276 277 278 279 280
			$result = $command->search();
			if (empty($result['hits']['hits'])) {
				return [];
			}
			$column = [];
			foreach ($result['hits']['hits'] as $row) {
				$column[] = $row['_id'];
281
			}
282
			return $column;
283 284 285
		}
		return parent::column($field, $db);
	}
286
}