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

8
namespace yii\mongodb;
9 10 11

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

/**
15 16
 * ActiveQuery represents a Mongo query associated with an Active Record class.
 *
17 18 19 20 21 22 23 24
 * An ActiveQuery can be a normal query or be used in a relational context.
 *
 * ActiveQuery instances are usually created by [[ActiveRecord::find()]].
 * Relational queries are created by [[ActiveRecord::hasOne()]] and [[ActiveRecord::hasMany()]].
 *
 * Normal Query
 * ------------
 *
25 26 27 28 29 30 31 32 33 34 35 36
 * ActiveQuery instances are usually created by [[ActiveRecord::find()]].
 *
 * 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.
 * - [[asArray()]]: whether to return each record as an array.
 *
 * These options can be configured using methods of the same name. For example:
 *
37
 * ```php
38
 * $customers = Customer::find()->with('orders')->asArray()->all();
39 40 41 42 43 44 45 46 47 48 49 50
 * ```
 *
 * 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
51
 * of different collections; and the multiplicity of the relation is indicated by [[multiple]].
52
 *
53
 * If a relation involves a junction collection, it may be specified by [[via()]].
54 55
 * This methods may only be called in a relational context. Same is true for [[inverseOf()]], which
 * marks a relation as inverse of another relation.
56
 *
Qiang Xue committed
57 58
 * @property Collection $collection Collection instance. This property is read-only.
 *
59 60 61
 * @author Paul Klimov <klimov.paul@gmail.com>
 * @since 2.0
 */
62
class ActiveQuery extends Query implements ActiveQueryInterface
63
{
64 65
    use ActiveQueryTrait;
    use ActiveRelationTrait;
66

67 68 69 70 71
    /**
     * @event Event an event that is triggered when the query is initialized via [[init()]].
     */
    const EVENT_INIT = 'init';

Qiang Xue committed
72 73 74 75 76 77 78 79 80 81 82 83

    /**
     * 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);
    }

84 85 86 87 88 89 90 91 92 93 94 95
    /**
     * 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);
    }

96 97 98 99 100 101 102 103 104
    /**
     * @inheritdoc
     */
    protected function buildCursor($db = null)
    {
        if ($this->primaryModel !== null) {
            // lazy loading
            if ($this->via instanceof self) {
                // via pivot collection
105
                $viaModels = $this->via->findJunctionRows([$this->primaryModel]);
106 107 108
                $this->filterByModels($viaModels);
            } elseif (is_array($this->via)) {
                // via relation
109
                /* @var $viaQuery ActiveQuery */
110 111 112 113 114 115 116 117 118 119 120 121 122 123
                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]);
            }
        }
124

125 126
        return parent::buildCursor($db);
    }
127

128 129
    /**
     * Executes query and returns all results as an array.
130 131 132
     * @param Connection $db the Mongo connection used to execute the query.
     * If null, the Mongo connection returned by [[modelClass]] will be used.
     * @return array the query results. If the query results in nothing, an empty array will be returned.
133 134 135 136 137
     */
    public function all($db = null)
    {
        $cursor = $this->buildCursor($db);
        $rows = $this->fetchRows($cursor);
138

139
        return $this->populate($rows);
140 141 142 143
    }

    /**
     * Executes query and returns a single row of result.
144 145
     * @param Connection $db the Mongo connection used to execute the query.
     * If null, the Mongo connection returned by [[modelClass]] will be used.
146
     * @return ActiveRecord|array|null a single row of query result. Depending on the setting of [[asArray]],
147 148
     * the query result may be either an array or an ActiveRecord object. Null will be returned
     * if the query results in nothing.
149 150 151 152 153
     */
    public function one($db = null)
    {
        $row = parent::one($db);
        if ($row !== false) {
154 155 156 157 158 159
            $models = $this->populate([$row]);
            return reset($models) ?: null;
        } else {
            return null;
        }
    }
160

161 162 163 164 165 166 167 168 169 170 171
    /**
     * Performs 'findAndModify' query and returns a single row of result.
     * Warning: in case 'new' option is set to 'false' (which is by default) usage of this method may lead
     * to unexpected behavior at some Active Record features, because object will be populated by outdated data.
     * @param array $update update criteria
     * @param array $options list of options in format: optionName => optionValue.
     * @param Connection $db the Mongo connection used to execute the query.
     * @return ActiveRecord|array|null the original document, or the modified document when $options['new'] is set.
     * 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.
     */
172
    public function modify($update, $options = [], $db = null)
173
    {
174
        $row = parent::modify($update, $options, $db);
175 176 177
        if ($row !== null) {
            $models = $this->populate([$row]);
            return reset($models) ?: null;
178 179 180 181 182 183 184
        } else {
            return null;
        }
    }

    /**
     * Returns the Mongo collection for this query.
185
     * @param Connection $db Mongo connection.
186 187 188 189
     * @return Collection collection instance.
     */
    public function getCollection($db = null)
    {
190
        /* @var $modelClass ActiveRecord */
191 192 193 194 195 196 197 198 199 200
        $modelClass = $this->modelClass;
        if ($db === null) {
            $db = $modelClass::getDb();
        }
        if ($this->from === null) {
            $this->from = $modelClass::collectionName();
        }

        return $db->getCollection($this->from);
    }
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226

    /**
     * Converts the raw query results into the format as specified by this query.
     * This method is internally used to convert the data fetched from MongoDB
     * into the format as required by this query.
     * @param array $rows the raw query result from MongoDB
     * @return array the converted query result
     */
    public function populate($rows)
    {
        if (empty($rows)) {
            return [];
        }

        $models = $this->createModels($rows);
        if (!empty($this->with)) {
            $this->findWith($this->with, $models);
        }
        if (!$this->asArray) {
            foreach ($models as $model) {
                $model->afterFind();
            }
        }

        return $models;
    }
AlexGx committed
227
}