ActiveQuery.php 9.57 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 78
    use ActiveQueryTrait;
    use ActiveRelationTrait;
79

80 81 82 83 84
    /**
     * @event Event an event that is triggered when the query is initialized via [[init()]].
     */
    const EVENT_INIT = 'init';

85

Qiang Xue committed
86 87 88 89 90 91 92 93 94 95 96
    /**
     * 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);
    }

97 98 99 100 101 102 103 104 105 106 107 108
    /**
     * 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);
    }

109 110
    /**
     * Creates a DB command that can be used to execute this query.
111 112 113
     * @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.
114 115 116 117 118 119 120
     */
    public function createCommand($db = null)
    {
        if ($this->primaryModel !== null) {
            // lazy loading
            if (is_array($this->via)) {
                // via relation
121
                /* @var $viaQuery ActiveQuery */
122 123 124 125 126 127 128 129 130 131 132 133 134 135
                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]);
            }
        }
136

137
        /* @var $modelClass ActiveRecord */
138 139 140 141
        $modelClass = $this->modelClass;
        if ($db === null) {
            $db = $modelClass::getDb();
        }
142

143 144 145 146 147 148 149 150
        if ($this->type === null) {
            $this->type = $modelClass::type();
        }
        if ($this->index === null) {
            $this->index = $modelClass::index();
            $this->type = $modelClass::type();
        }
        $commandConfig = $db->getQueryBuilder()->build($this);
151

152 153
        return $db->createCommand($commandConfig);
    }
154

155 156
    /**
     * Executes query and returns all results as an array.
157 158 159
     * @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.
160 161 162
     */
    public function all($db = null)
    {
163 164 165 166 167
        if ($this->asArray) {
            // TODO implement with
            return parent::all($db);
        }

168 169 170 171 172 173 174 175
        $result = $this->createCommand($db)->search();
        if (empty($result['hits']['hits'])) {
            return [];
        }
        $models = $this->createModels($result['hits']['hits']);
        if (!empty($this->with)) {
            $this->findWith($this->with, $models);
        }
176 177
        foreach ($models as $model) {
            $model->afterFind();
178
        }
179

180 181
        return $models;
    }
182

183 184
    /**
     * Executes query and returns a single row of result.
185 186
     * @param Connection $db the DB connection used to create the DB command.
     * If null, the DB connection returned by [[modelClass]] will be used.
187
     * @return ActiveRecord|array|null a single row of query result. Depending on the setting of [[asArray]],
188 189
     * the query result may be either an array or an ActiveRecord object. Null will be returned
     * if the query results in nothing.
190 191 192 193 194 195 196
     */
    public function one($db = null)
    {
        if (($result = parent::one($db)) === false) {
            return null;
        }
        if ($this->asArray) {
197
            // TODO implement with
198
//            /* @var $modelClass ActiveRecord */
199 200 201 202 203 204 205 206 207 208 209 210 211
//            $modelClass = $this->modelClass;
//            $model = $result['_source'];
//            $pk = $modelClass::primaryKey()[0];
//            if ($pk === '_id') {
//                $model['_id'] = $result['_id'];
//            }
//            $model['_score'] = $result['_score'];
//            if (!empty($this->with)) {
//                $models = [$model];
//                $this->findWith($this->with, $models);
//                $model = $models[0];
//            }
            return $result;
212
        } else {
213
            /* @var $class ActiveRecord */
214 215 216
            $class = $this->modelClass;
            $model = $class::instantiate($result);
            $class::populateRecord($model, $result);
217 218 219 220 221
            if (!empty($this->with)) {
                $models = [$model];
                $this->findWith($this->with, $models);
                $model = $models[0];
            }
222
            $model->afterFind();
223
            return $model;
224 225 226 227 228 229 230 231 232
        }
    }

    /**
     * @inheritdoc
     */
    public function search($db = null, $options = [])
    {
        $result = $this->createCommand($db)->search($options);
233 234
        // TODO implement with for asArray
        if (!empty($result['hits']['hits']) && !$this->asArray) {
235 236 237 238
            $models = $this->createModels($result['hits']['hits']);
            if (!empty($this->with)) {
                $this->findWith($this->with, $models);
            }
239 240
            foreach ($models as $model) {
                $model->afterFind();
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
            }
            $result['hits']['hits'] = $models;
        }

        return $result;
    }

    /**
     * @inheritdoc
     */
    public function column($field, $db = null)
    {
        if ($field == '_id') {
            $command = $this->createCommand($db);
            $command->queryParts['fields'] = [];
256
            $command->queryParts['_source'] = false;
257 258 259 260 261 262 263 264 265 266 267 268 269 270
            $result = $command->search();
            if (empty($result['hits']['hits'])) {
                return [];
            }
            $column = [];
            foreach ($result['hits']['hits'] as $row) {
                $column[] = $row['_id'];
            }

            return $column;
        }

        return parent::column($field, $db);
    }
271
}