Yii2 Bootstrap 3
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

322 lines
9.2 KiB

13 years ago
<?php
/**
* @author Qiang Xue <qiang.xue@gmail.com>
* @link http://www.yiiframework.com/
* @copyright Copyright (c) 2008 Yii Software LLC
13 years ago
* @license http://www.yiiframework.com/license/
*/
namespace yii\db;
13 years ago
12 years ago
/**
* ActiveQuery represents a DB query associated with an Active Record class.
*
* ActiveQuery instances are usually created by [[ActiveRecord::find()]], [[ActiveRecord::findBySql()]]
* and [[ActiveRecord::count()]].
*
* 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.
* - [[sum()]]: returns the sum over the specified column.
* - [[average()]]: returns the average over the specified column.
* - [[min()]]: returns the min over the specified column.
* - [[max()]]: returns the max over the specified column.
* - [[scalar()]]: returns the value of the first column in the first row of the query result.
12 years ago
* - [[exists()]]: returns a value indicating whether the query result has data or not.
*
* 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:
*
12 years ago
* - [[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.
12 years ago
*
* These options can be configured using methods of the same name. For example:
*
* ~~~
* $customers = Customer::find()->with('orders')->asArray()->all();
* ~~~
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @since 2.0
*/
12 years ago
class ActiveQuery extends Query
12 years ago
{
/**
* @var string the name of the ActiveRecord class.
*/
public $modelClass;
/**
* @var array list of relations that this query should be performed with
*/
12 years ago
public $with;
12 years ago
/**
* @var boolean whether to return each record as an array. If false (default), an object
* of [[modelClass]] will be created to represent each record.
*/
public $asArray;
/**
* @var string the SQL statement to be executed for retrieving AR records.
* This is set by [[ActiveRecord::findBySql()]].
*/
public $sql;
/**
* PHP magic method.
* This method allows calling static method defined in [[modelClass]] via this query object.
* It is mainly implemented for supporting the feature of scope.
* @param string $name the method name to be called
* @param array $params the parameters passed to the method
* @return mixed the method return result
*/
public function __call($name, $params)
{
if (method_exists($this->modelClass, $name)) {
array_unshift($params, $this);
12 years ago
call_user_func_array(array($this->modelClass, $name), $params);
return $this;
} else {
return parent::__call($name, $params);
}
}
/**
12 years ago
* 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.
12 years ago
* @return array the query results. If the query results in nothing, an empty array will be returned.
*/
public function all($db = null)
12 years ago
{
$command = $this->createCommand($db);
12 years ago
$rows = $command->queryAll();
if (!empty($rows)) {
$models = $this->createModels($rows);
if (!empty($this->with)) {
12 years ago
$this->populateRelations($models, $this->with);
}
return $models;
} else {
12 years ago
return array();
}
12 years ago
}
/**
* 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.
12 years ago
* @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
12 years ago
* if the query results in nothing.
*/
public function one($db = null)
12 years ago
{
$command = $this->createCommand($db);
$row = $command->queryOne();
if ($row !== false) {
if ($this->asArray) {
$model = $row;
} else {
/** @var $class ActiveRecord */
$class = $this->modelClass;
$model = $class::create($row);
}
12 years ago
if (!empty($this->with)) {
12 years ago
$models = array($model);
12 years ago
$this->populateRelations($models, $this->with);
12 years ago
$model = $models[0];
12 years ago
}
return $model;
} else {
return null;
12 years ago
}
12 years ago
}
/**
12 years ago
* Creates a DB command that can be used to execute this query.
12 years ago
* @param Connection $db the DB connection used to create the DB command.
* If null, the DB connection returned by [[modelClass]] will be used.
12 years ago
* @return Command the created DB command instance.
12 years ago
*/
12 years ago
public function createCommand($db = null)
12 years ago
{
12 years ago
/** @var $modelClass ActiveRecord */
12 years ago
$modelClass = $this->modelClass;
12 years ago
if ($db === null) {
12 years ago
$db = $modelClass::getDb();
12 years ago
}
$params = $this->params;
12 years ago
if ($this->sql === null) {
if ($this->from === null) {
$tableName = $modelClass::tableName();
if ($this->select === null && !empty($this->join)) {
$this->select = array("$tableName.*");
}
12 years ago
$this->from = array($tableName);
}
list ($this->sql, $params) = $db->getQueryBuilder()->build($this);
12 years ago
}
return $db->createCommand($this->sql, $params);
12 years ago
}
12 years ago
/**
* Sets the [[asArray]] property.
* @param boolean $value whether to return the query results in terms of arrays instead of Active Records.
* @return static the query object itself
12 years ago
*/
12 years ago
public function asArray($value = true)
{
$this->asArray = $value;
return $this;
}
12 years ago
/**
* Specifies the relations with which this query should be performed.
*
* The parameters to this method can be either one or multiple strings, or a single array
* of relation names and the optional callbacks to customize the relations.
*
* The followings are some usage examples:
*
* ~~~
* // find customers together with their orders and country
* Customer::find()->with('orders', 'country')->all();
* // find customers together with their country and orders of status 1
* Customer::find()->with(array(
* 'orders' => function($query) {
* $query->andWhere('status = 1');
* },
* 'country',
* ))->all();
* ~~~
*
* @return static the query object itself
12 years ago
*/
12 years ago
public function with()
{
$this->with = func_get_args();
if (isset($this->with[0]) && is_array($this->with[0])) {
// the parameter is given as an array
$this->with = $this->with[0];
}
return $this;
}
12 years ago
/**
* Sets the [[indexBy]] property.
* @param string|callable $column the name of the column by which the query results should be indexed by.
* This can also be a callable (e.g. anonymous function) that returns the index value based on the given
* row or model data. The signature of the callable should be:
*
* ~~~
* // $model is an AR instance when `asArray` is false,
* // or an array of column values when `asArray` is true.
* function ($model)
* {
* // return the index value corresponding to $model
* }
* ~~~
*
* @return static the query object itself
12 years ago
*/
12 years ago
public function indexBy($column)
12 years ago
{
return parent::indexBy($column);
12 years ago
}
12 years ago
private function createModels($rows)
12 years ago
{
$models = array();
if ($this->asArray) {
12 years ago
if ($this->indexBy === null) {
12 years ago
return $rows;
}
foreach ($rows as $row) {
if (is_string($this->indexBy)) {
$key = $row[$this->indexBy];
} else {
$key = call_user_func($this->indexBy, $row);
}
$models[$key] = $row;
12 years ago
}
} else {
/** @var $class ActiveRecord */
$class = $this->modelClass;
12 years ago
if ($this->indexBy === null) {
12 years ago
foreach ($rows as $row) {
$models[] = $class::create($row);
}
} else {
foreach ($rows as $row) {
$model = $class::create($row);
if (is_string($this->indexBy)) {
$key = $model->{$this->indexBy};
} else {
$key = call_user_func($this->indexBy, $model);
}
$models[$key] = $model;
12 years ago
}
}
}
return $models;
}
12 years ago
12 years ago
private function populateRelations(&$models, $with)
12 years ago
{
$primaryModel = new $this->modelClass;
12 years ago
$relations = $this->normalizeRelations($primaryModel, $with);
foreach ($relations as $name => $relation) {
12 years ago
if ($relation->asArray === null) {
// inherit asArray from primary query
$relation->asArray = $this->asArray;
}
12 years ago
$relation->findWith($name, $models);
12 years ago
}
}
12 years ago
/**
* @param ActiveRecord $model
* @param array $with
* @return ActiveRelation[]
*/
12 years ago
private function normalizeRelations($model, $with)
12 years ago
{
$relations = array();
12 years ago
foreach ($with as $name => $callback) {
12 years ago
if (is_integer($name)) {
12 years ago
$name = $callback;
$callback = null;
12 years ago
}
if (($pos = strpos($name, '.')) !== false) {
// with sub-relations
$childName = substr($name, $pos + 1);
$name = substr($name, 0, $pos);
} else {
$childName = null;
}
$t = strtolower($name);
if (!isset($relations[$t])) {
$relation = $model->getRelation($name);
$relation->primaryModel = null;
$relations[$t] = $relation;
12 years ago
} else {
$relation = $relations[$t];
12 years ago
}
if (isset($childName)) {
12 years ago
$relation->with[$childName] = $callback;
} elseif ($callback !== null) {
call_user_func($callback, $relation);
12 years ago
}
}
return $relations;
}
12 years ago
}