Error202
/
yii2-bootstrap
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

...

tags/2.0.0-beta
Qiang Xue 13 years ago
parent
965fe5c4d2
commit
3210a2171c
6 changed files with 132 additions and 880 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      framework/base/Component.php
  2. 736
      framework/db/ar/ActiveFinder.php
  3. 198
      framework/db/ar/ActiveQuery.php
  4. 15
      framework/db/ar/ActiveRecord.php
  5. 9
      framework/db/ar/ActiveRelation.php
  6. 52
      tests/unit/framework/db/ar/ActiveRecordTest.php

2
framework/base/Component.php
Unescape View File

@ -69,7 +69,7 @@ namespace yii\base;
* @author Qiang Xue <qiang.xue@gmail.com> * @author Qiang Xue <qiang.xue@gmail.com>
* @since 2.0 * @since 2.0
*/ */
class Component extends Object class Component extends \yii\base\Object
{ {
/** /**
* @var Vector[] the attached event handlers (event name => handlers) * @var Vector[] the attached event handlers (event name => handlers)

736
framework/db/ar/ActiveFinder.php
Unescape View File

@ -31,686 +31,92 @@ use yii\db\Exception;
* todo: scope * todo: scope
* todo: test via option * todo: test via option
* todo: count, sum, exists * todo: count, sum, exists
todo: inner join with one or multiple relations as filters
joinType should default to inner join in this case
* *
* @property integer $count * @property integer $count
* *
* @author Qiang Xue <qiang.xue@gmail.com> * @author Qiang Xue <qiang.xue@gmail.com>
* @since 2.0 * @since 2.0
*/ */
class ActiveFinder extends \yii\base\Object implements \IteratorAggregate, \ArrayAccess, \Countable class ActiveFinder extends \yii\base\Object
{ {
/** /**
* @var string the name of the ActiveRecord class. * @var \yii\db\dao\Connection
*/ */
public $modelClass; public $connection;
/**
* @var Query the Query object
*/
public $query;
/**
* @var array list of relations that this query should be performed with
*/
public $with;
/**
* @var string the table alias to be used for query
*/
public $tableAlias;
/**
* @var string the name of the column that the result should be indexed by
*/
public $indexBy;
/**
* @var boolean whether to return query results as arrays
*/
public $asArray;
/**
* @var array list of scopes that should be applied to this query
*/
public $scopes;
/**
* @var array list of query results
*/
public $records;
public $sql;
/**
* @param string $modelClass the name of the ActiveRecord class.
*/
public function __construct($modelClass)
{
$this->modelClass = $modelClass;
$this->query = new Query;
}
/**
* Executes query and returns all results as an array.
* @return array the query results. If the query results in nothing, an empty array will be returned.
*/
public function all()
{
if ($this->records === null) {
$this->records = $this->findRecords();
}
return $this->records;
}
/**
* Executes query and returns a single row of result.
* @return null|array|ActiveRecord the 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()
{
if ($this->records === null) {
$this->records = $this->findRecords();
}
return isset($this->records[0]) ? $this->records[0] : null;
}
public function exists()
{
// todo
return $this->select(array('1'))->asArray(true)->one() !== null;
}
public function asArray($value = true)
{
$this->asArray = $value;
return $this;
}
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;
}
public function indexBy($column)
{
$this->indexBy = $column;
return $this;
}
public function tableAlias($value)
{
$this->tableAlias = $value;
return $this;
}
/**
* Returns the database connection used by this query.
* This method returns the connection used by the [[modelClass]].
* @return \yii\db\dao\Connection the database connection used by this query
*/
public function getDbConnection()
{
$class = $this->modelClass;
return $class::getDbConnection();
}
/**
* Returns the number of items in the vector.
* @return integer the number of items in the vector
*/
public function getCount()
{
return $this->count();
}
/**
* Sets the parameters about query caching.
* This is a shortcut method to {@link CDbConnection::cache()}.
* It changes the query caching parameter of the {@link dbConnection} instance.
* @param integer $duration the number of seconds that query results may remain valid in cache.
* If this is 0, the caching will be disabled.
* @param CCacheDependency $dependency the dependency that will be used when saving the query results into cache.
* @param integer $queryCount number of SQL queries that need to be cached after calling this method. Defaults to 1,
* meaning that the next SQL query will be cached.
* @return ActiveRecord the active record instance itself.
*/
public function cache($duration, $dependency = null, $queryCount = 1)
{
$this->getDbConnection()->cache($duration, $dependency, $queryCount);
return $this;
}
/** public function __construct($connection)
* Returns an iterator for traversing the items in the vector.
* This method is required by the SPL interface `IteratorAggregate`.
* It will be implicitly called when you use `foreach` to traverse the vector.
* @return VectorIterator an iterator for traversing the items in the vector.
*/
public function getIterator()
{ {
if ($this->records === null) { $this->connection = $connection;
$this->records = $this->findRecords();
}
return new VectorIterator($this->records);
} }
/** /**
* Returns the number of items in the vector. * @param \yii\db\ar\ActiveQuery $query
* This method is required by the SPL `Countable` interface. * @param bool $all
* It will be implicitly called when you use `count($vector)`. * @return array
* @param boolean $bySql whether to get the count by performing a SQL COUNT query.
* If this is false, it will count the number of records brought back by this query.
* @return integer number of items in the vector.
*/ */
public function count($bySql = false) public function findRecords($query, $all = true)
{ {
if ($bySql) { if ($query->sql !== null) {
return $this->performCountQuery(); $sql = $query->sql;
} else { } else {
if ($this->records === null) { $this->initFrom($query);
$this->records = $this->findRecords(); $this->applyScopes($query);
// todo: filter
$sql = $this->connection->getQueryBuilder()->build($query);
if (strpos($sql, '@.') !== false) {
if ($query->tableAlias !== null) {
$alias = $this->connection->quoteTableName($query->tableAlias) . '.';
} else {
$class = $query->modelClass;
$alias = $this->connection->quoteTableName($class::tableName()) . '.';
}
$sql = str_replace('@.', $alias, $sql);
} }
return count($this->records);
}
}
/**
* Returns a value indicating whether there is an item at the specified offset.
* This method is required by the SPL interface `ArrayAccess`.
* It is implicitly called when you use something like `isset($vector[$offset])`.
* @param integer $offset the offset to be checked
* @return boolean whether there is an item at the specified offset.
*/
public function offsetExists($offset)
{
if ($this->records === null) {
$this->records = $this->findRecords();
}
return isset($this->records[$offset]);
}
/**
* Returns the item at the specified offset.
* This method is required by the SPL interface `ArrayAccess`.
* It is implicitly called when you use something like `$value = $vector[$offset];`.
* This is equivalent to [[itemAt]].
* @param integer $offset the offset to retrieve item.
* @return ActiveRecord the item at the offset
* @throws Exception if the offset is out of range
*/
public function offsetGet($offset)
{
if ($this->records === null) {
$this->records = $this->findRecords();
} }
return isset($this->records[$offset]) ? $this->records[$offset] : null; $command = $this->connection->createCommand($sql, $query->params);
}
/** if ($all) {
* Sets the item at the specified offset. $rows = $command->queryAll();
* This method is required by the SPL interface `ArrayAccess`.
* It is implicitly called when you use something like `$vector[$offset] = $item;`.
* If the offset is null or equal to the number of the existing items,
* the new item will be appended to the vector.
* Otherwise, the existing item at the offset will be replaced with the new item.
* @param integer $offset the offset to set item
* @param ActiveRecord $item the item value
* @throws Exception if the offset is out of range, or the vector is read only.
*/
public function offsetSet($offset, $item)
{
if ($this->records === null) {
$this->records = $this->findRecords();
}
$this->records[$offset] = $item;
}
/**
* Unsets the item at the specified offset.
* This method is required by the SPL interface `ArrayAccess`.
* It is implicitly called when you use something like `unset($vector[$offset])`.
* This is equivalent to [[removeAt]].
* @param integer $offset the offset to unset item
* @throws Exception if the offset is out of range, or the vector is read only.
*/
public function offsetUnset($offset)
{
if ($this->records === null) {
$this->records = $this->findRecords();
}
unset($this->records[$offset]);
}
/**
* Sets the SELECT part of the query.
* @param string|array $columns the columns to be selected.
* Columns can be specified in either a string (e.g. "id, name") or an array (e.g. array('id', 'name')).
* Columns can contain table prefixes (e.g. "tbl_user.id") and/or column aliases (e.g. "tbl_user.id AS user_id").
* The method will automatically quote the column names unless a column contains some parenthesis
* (which means the column contains a DB expression).
* @param string $option additional option that should be appended to the 'SELECT' keyword. For example,
* in MySQL, the option 'SQL_CALC_FOUND_ROWS' can be used.
* @return ActiveFinder the query object itself
*/
public function select($columns, $option = '')
{
$this->query->select($columns, $option);
return $this;
}
/**
* Sets the value indicating whether to SELECT DISTINCT or not.
* @param bool $value whether to SELECT DISTINCT or not.
* @return ActiveFinder the query object itself
*/
public function distinct($value = true)
{
$this->query->distinct($value);
return $this;
}
/**
* Sets the FROM part of the query.
* @param string|array $tables the table(s) to be selected from. This can be either a string (e.g. 'tbl_user')
* or an array (e.g. array('tbl_user', 'tbl_profile')) specifying one or several table names.
* Table names can contain schema prefixes (e.g. 'public.tbl_user') and/or table aliases (e.g. 'tbl_user u').
* The method will automatically quote the table names unless it contains some parenthesis
* (which means the table is given as a sub-query or DB expression).
* @return ActiveFinder the query object itself
*/
public function from($tables)
{
$this->query->from($tables);
return $this;
}
/**
* Sets the WHERE part of the query.
*
* The method requires a $condition parameter, and optionally a $params parameter
* specifying the values to be bound to the query.
*
* The $condition parameter should be either a string (e.g. 'id=1') or an array.
* If the latter, it must be in one of the following two formats:
*
* - hash format: `array('column1' => value1, 'column2' => value2, ...)`
* - operator format: `array(operator, operand1, operand2, ...)`
*
* A condition in hash format represents the following SQL expression in general:
* `column1=value1 AND column2=value2 AND ...`. In case when a value is an array,
* an `IN` expression will be generated. And if a value is null, `IS NULL` will be used
* in the generated expression. Below are some examples:
*
* - `array('type'=>1, 'status'=>2)` generates `(type=1) AND (status=2)`.
* - `array('id'=>array(1,2,3), 'status'=>2)` generates `(id IN (1,2,3)) AND (status=2)`.
* - `array('status'=>null) generates `status IS NULL`.
*
* A condition in operator format generates the SQL expression according to the specified operator, which
* can be one of the followings:
*
* - `and`: the operands should be concatenated together using `AND`. For example,
* `array('and', 'id=1', 'id=2')` will generate `id=1 AND id=2`. If an operand is an array,
* it will be converted into a string using the rules described here. For example,
* `array('and', 'type=1', array('or', 'id=1', 'id=2'))` will generate `type=1 AND (id=1 OR id=2)`.
* The method will NOT do any quoting or escaping.
*
* - `or`: similar to the `and` operator except that the operands are concatenated using `OR`.
*
* - `between`: operand 1 should be the column name, and operand 2 and 3 should be the
* starting and ending values of the range that the column is in.
* For example, `array('between', 'id', 1, 10)` will generate `id BETWEEN 1 AND 10`.
*
* - `not between`: similar to `between` except the `BETWEEN` is replaced with `NOT BETWEEN`
* in the generated condition.
*
* - `in`: operand 1 should be a column or DB expression, and operand 2 be an array representing
* the range of the values that the column or DB expression should be in. For example,
* `array('in', 'id', array(1,2,3))` will generate `id IN (1,2,3)`.
* The method will properly quote the column name and escape values in the range.
*
* - `not in`: similar to the `in` operator except that `IN` is replaced with `NOT IN` in the generated condition.
*
* - `like`: operand 1 should be a column or DB expression, and operand 2 be a string or an array representing
* the values that the column or DB expression should be like.
* For example, `array('like', 'name', '%tester%')` will generate `name LIKE '%tester%'`.
* When the value range is given as an array, multiple `LIKE` predicates will be generated and concatenated
* using `AND`. For example, `array('like', 'name', array('%test%', '%sample%'))` will generate
* `name LIKE '%test%' AND name LIKE '%sample%'`.
* The method will properly quote the column name and escape values in the range.
*
* - `or like`: similar to the `like` operator except that `OR` is used to concatenate the `LIKE`
* predicates when operand 2 is an array.
*
* - `not like`: similar to the `like` operator except that `LIKE` is replaced with `NOT LIKE`
* in the generated condition.
*
* - `or not like`: similar to the `not like` operator except that `OR` is used to concatenate
* the `NOT LIKE` predicates.
*
* @param string|array $condition the conditions that should be put in the WHERE part.
* @param array $params the parameters (name=>value) to be bound to the query.
* For anonymous parameters, they can alternatively be specified as separate parameters to this method.
* For example, `where('type=? AND status=?', 100, 1)`.
* @return ActiveFinder the query object itself
* @see andWhere()
* @see orWhere()
*/
public function where($condition, $params = array())
{
if (is_array($params)) {
$this->query->where($condition, $params);
} else {
call_user_func_array(array($this->query, __FUNCTION__), func_get_args());
}
return $this;
}
/**
* Adds an additional WHERE condition to the existing one.
* The new condition and the existing one will be joined using the 'AND' operator.
* @param string|array $condition the new WHERE condition. Please refer to [[where()]]
* on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query.
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters.
* @return ActiveFinder the query object itself
* @see where()
* @see orWhere()
*/
public function andWhere($condition, $params = array())
{
if (is_array($params)) {
$this->query->andWhere($condition, $params);
} else { } else {
call_user_func_array(array($this->query, __FUNCTION__), func_get_args()); $row = $command->queryRow();
} if ($row === false) {
return $this; return array();
} }
$rows = array($row);
/**
* Adds an additional WHERE condition to the existing one.
* The new condition and the existing one will be joined using the 'OR' operator.
* @param string|array $condition the new WHERE condition. Please refer to [[where()]]
* on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query.
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters.
* @return ActiveFinder the query object itself
* @see where()
* @see andWhere()
*/
public function orWhere($condition, $params = array())
{
if (is_array($params)) {
$this->query->orWhere($condition, $params);
} else {
call_user_func_array(array($this->query, __FUNCTION__), func_get_args());
}
return $this;
}
/**
* Appends a JOIN part to the query.
* The first parameter specifies what type of join it is.
* @param string $type the type of join, such as INNER JOIN, LEFT JOIN.
* @param string $table the table to be joined.
* Table name can contain schema prefix (e.g. 'public.tbl_user') and/or table alias (e.g. 'tbl_user u').
* The method will automatically quote the table name unless it contains some parenthesis
* (which means the table is given as a sub-query or DB expression).
* @param string|array $on the join condition that should appear in the ON part.
* Please refer to [[where()]] on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query.
* @return Query the query object itself
*/
public function join($type, $table, $on = '', $params = array())
{
$this->query->join($type, $table, $on, $params);
return $this;
}
/**
* Appends an INNER JOIN part to the query.
* @param string $table the table to be joined.
* Table name can contain schema prefix (e.g. 'public.tbl_user') and/or table alias (e.g. 'tbl_user u').
* The method will automatically quote the table name unless it contains some parenthesis
* (which means the table is given as a sub-query or DB expression).
* @param string|array $on the join condition that should appear in the ON part.
* Please refer to [[where()]] on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query.
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters.
* @return ActiveFinder the query object itself
*/
public function innerJoin($table, $on, $params = array())
{
$this->query->join($table, $on, $params);
return $this;
}
/**
* Appends a LEFT OUTER JOIN part to the query.
* @param string $table the table to be joined.
* Table name can contain schema prefix (e.g. 'public.tbl_user') and/or table alias (e.g. 'tbl_user u').
* The method will automatically quote the table name unless it contains some parenthesis
* (which means the table is given as a sub-query or DB expression).
* @param string|array $on the join condition that should appear in the ON part.
* Please refer to [[where()]] on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query
* @return ActiveFinder the query object itself
*/
public function leftJoin($table, $on, $params = array())
{
$this->query->leftJoin($table, $on, $params);
return $this;
}
/**
* Appends a RIGHT OUTER JOIN part to the query.
* @param string $table the table to be joined.
* Table name can contain schema prefix (e.g. 'public.tbl_user') and/or table alias (e.g. 'tbl_user u').
* The method will automatically quote the table name unless it contains some parenthesis
* (which means the table is given as a sub-query or DB expression).
* @param string|array $on the join condition that should appear in the ON part.
* Please refer to [[where()]] on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query
* @return ActiveFinder the query object itself
*/
public function rightJoin($table, $on, $params = array())
{
$this->query->rightJoin($table, $on, $params);
return $this;
}
/**
* Sets the GROUP BY part of the query.
* @param string|array $columns the columns to be grouped by.
* Columns can be specified in either a string (e.g. "id, name") or an array (e.g. array('id', 'name')).
* The method will automatically quote the column names unless a column contains some parenthesis
* (which means the column contains a DB expression).
* @return ActiveFinder the query object itself
* @see addGroupBy()
*/
public function groupBy($columns)
{
$this->query->groupBy($columns);
return $this;
}
/**
* Adds additional group-by columns to the existing ones.
* @param string|array $columns additional columns to be grouped by.
* Columns can be specified in either a string (e.g. "id, name") or an array (e.g. array('id', 'name')).
* The method will automatically quote the column names unless a column contains some parenthesis
* (which means the column contains a DB expression).
* @return ActiveFinder the query object itself
* @see groupBy()
*/
public function addGroupBy($columns)
{
$this->query->addGroupBy($columns);
return $this;
}
/**
* Sets the HAVING part of the query.
* @param string|array $condition the conditions to be put after HAVING.
* Please refer to [[where()]] on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query.
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters.
* @return ActiveFinder the query object itself
* @see andHaving()
* @see orHaving()
*/
public function having($condition, $params = array())
{
if (is_array($params)) {
$this->query->having($condition, $params);
} else {
call_user_func_array(array($this->query, __FUNCTION__), func_get_args());
}
return $this;
}
/**
* Adds an additional HAVING condition to the existing one.
* The new condition and the existing one will be joined using the 'AND' operator.
* @param string|array $condition the new HAVING condition. Please refer to [[where()]]
* on how to specify this parameter.
* @param array $params the parameters (name=>value) to be bound to the query.
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters.
* @return ActiveFinder the query object itself
* @see having()
* @see orHaving()
*/
public function andHaving($condition, $params = array())
{
if (is_array($params)) {
$this->query->andHaving($condition, $params);
} else {
call_user_func_array(array($this->query, __FUNCTION__), func_get_args());
} }
return $this;
}
/** $records = array();
* Adds an additional HAVING condition to the existing one. if ($query->asArray) {
* The new condition and the existing one will be joined using the 'OR' operator. if ($query->indexBy === null) {
* @param string|array $condition the new HAVING condition. Please refer to [[where()]] return $rows;
* on how to specify this parameter. }
* @param array $params the parameters (name=>value) to be bound to the query. foreach ($rows as $row) {
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters. $records[$row[$query->indexBy]] = $row;
* @return ActiveFinder the query object itself }
* @see having()
* @see andHaving()
*/
public function orHaving($condition, $params = array())
{
if (is_array($params)) {
$this->query->orHaving($condition, $params);
} else { } else {
call_user_func_array(array($this->query, __FUNCTION__), func_get_args()); $class = $query->modelClass;
if ($query->indexBy === null) {
foreach ($rows as $row) {
$records[] = $class::createRecord($row);
}
} else {
foreach ($rows as $row) {
$records[$row[$query->indexBy]] = $class::createRecord($row);
}
}
} }
return $this; return $records;
}
/**
* Sets the ORDER BY part of the query.
* @param string|array $columns the columns (and the directions) to be ordered by.
* Columns can be specified in either a string (e.g. "id ASC, name DESC") or an array (e.g. array('id ASC', 'name DESC')).
* The method will automatically quote the column names unless a column contains some parenthesis
* (which means the column contains a DB expression).
* @return ActiveFinder the query object itself
* @see addOrderBy()
*/
public function orderBy($columns)
{
$this->query->orderBy($columns);
return $this;
}
/**
* Adds additional ORDER BY columns to the query.
* @param string|array $columns the columns (and the directions) to be ordered by.
* Columns can be specified in either a string (e.g. "id ASC, name DESC") or an array (e.g. array('id ASC', 'name DESC')).
* The method will automatically quote the column names unless a column contains some parenthesis
* (which means the column contains a DB expression).
* @return ActiveFinder the query object itself
* @see orderBy()
*/
public function addOrderBy($columns)
{
$this->query->addOrderBy($columns);
return $this;
}
/**
* Sets the LIMIT part of the query.
* @param integer $limit the limit
* @return ActiveFinder the query object itself
*/
public function limit($limit)
{
$this->query->limit($limit);
return $this;
}
/**
* Sets the OFFSET part of the query.
* @param integer $offset the offset
* @return ActiveFinder the query object itself
*/
public function offset($offset)
{
$this->query->offset($offset);
return $this;
}
/**
* Appends a SQL statement using UNION operator.
* @param string|Query $sql the SQL statement to be appended using UNION
* @return ActiveFinder the query object itself
*/
public function union($sql)
{
$this->query->union($sql);
return $this;
} }
public function getParams()
{
return $this->query->params;
}
/** public function findRelatedRecords($record, $relation, $params)
* Sets the parameters to be bound to the query.
* @param array list of query parameter values indexed by parameter placeholders.
* For example, `array(':name'=>'Dan', ':age'=>31)`.
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters.
* @return ActiveFinder the query object itself
* @see addParams()
*/
public function params($params)
{ {
$this->query->params($params);
return $this;
}
/**
* Adds additional parameters to be bound to the query.
* @param array list of query parameter values indexed by parameter placeholders.
* For example, `array(':name'=>'Dan', ':age'=>31)`.
* Please refer to [[where()]] on alternative syntax of specifying anonymous parameters.
* @return ActiveFinder the query object itself
* @see params()
*/
public function addParams($params)
{
$this->query->addParams($params);
return $this;
}
public function joinWith()
{
// todo: inner join with one or multiple relations as filters
} }
protected function findRecords() public function findRecordsWithRelations()
{ {
if (!empty($this->with)) { if (!empty($this->with)) {
// todo: handle findBySql() and limit cases // todo: handle findBySql() and limit cases
@ -762,32 +168,32 @@ class ActiveFinder extends \yii\base\Object implements \IteratorAggregate, \Arra
} }
} }
protected function performCountQuery()
{
if ($this->sql === null) {
$this->initFrom($this->query);
$this->query->select = 'COUNT(*)';
$command = $this->query->createCommand($this->getDbConnection());
$this->sql = $command->getSql();
} else {
$command = $this->getDbConnection()->createCommand($this->sql);
$command->bindValues($this->query->params);
}
return $command->queryScalar();
}
protected function initFrom($query) protected function initFrom($query)
{ {
if ($query->from === null) { if ($query->from === null) {
$modelClass = $this->modelClass; $modelClass = $query->modelClass;
$tableName = $modelClass::tableName(); $tableName = $modelClass::tableName();
if ($this->tableAlias !== null) { if ($query->tableAlias !== null) {
$tableName .= ' ' . $this->tableAlias; $tableName .= ' ' . $query->tableAlias;
} }
$query->from = array($tableName); $query->from = array($tableName);
} }
} }
protected function applyScopes($query)
{
if (is_array($query->scopes)) {
foreach ($query->scopes as $scope => $params) {
if (is_integer($scope)) {
$scope = $params;
$params = array();
}
array_unshift($params, $query);
call_user_func_array($scope, $params);
}
}
}
protected function buildRelationalQuery() protected function buildRelationalQuery()
{ {
$joinTree = new JoinElement($this, null, null); $joinTree = new JoinElement($this, null, null);

198
framework/db/ar/ActiveQuery.php
Unescape View File

@ -15,11 +15,12 @@ use yii\db\dao\BaseQuery;
use yii\db\Exception; use yii\db\Exception;
/** /**
* 1. eager loading, base limited and has has_many relations
* 2.
* ActiveFinder.php is ... * ActiveFinder.php is ...
* todo: add SQL monitor * todo: add SQL monitor
* todo: better handling on join() support in QueryBuilder: use regexp to detect table name and quote it * todo: better handling on join() support in QueryBuilder: use regexp to detect table name and quote it
* todo: do not support anonymous parameter binding * todo: do not support anonymous parameter binding
* todo: add ActiveFinderBuilder
* todo: quote join/on part of the relational query * todo: quote join/on part of the relational query
* todo: modify QueryBuilder about join() methods * todo: modify QueryBuilder about join() methods
* todo: unify ActiveFinder and ActiveRelation in query building process * todo: unify ActiveFinder and ActiveRelation in query building process
@ -48,6 +49,10 @@ class ActiveQuery extends BaseQuery implements \IteratorAggregate, \ArrayAccess,
*/ */
public $with; public $with;
/** /**
* @var array list of relations that should be used as filters for this query.
*/
public $filters;
/**
* @var string the table alias to be used for query * @var string the table alias to be used for query
*/ */
public $tableAlias; public $tableAlias;
@ -66,10 +71,14 @@ class ActiveQuery extends BaseQuery implements \IteratorAggregate, \ArrayAccess,
*/ */
public $scopes; public $scopes;
/** /**
* @var string the SQL statement to be executed to retrieve primary records.
* This is set by [[ActiveRecord::findBySql()]].
*/
public $sql;
/**
* @var array list of query results * @var array list of query results
*/ */
public $records; public $records;
public $sql;
/** /**
* @param string $modelClass the name of the ActiveRecord class. * @param string $modelClass the name of the ActiveRecord class.
@ -95,6 +104,16 @@ class ActiveQuery extends BaseQuery implements \IteratorAggregate, \ArrayAccess,
return $this; return $this;
} }
public function filters()
{
$this->filters = func_get_args();
if (isset($this->filters[0]) && is_array($this->filters[0])) {
// the parameter is given as an array
$this->filters = $this->filters[0];
}
return $this;
}
public function indexBy($column) public function indexBy($column)
{ {
$this->indexBy = $column; $this->indexBy = $column;
@ -129,7 +148,7 @@ class ActiveQuery extends BaseQuery implements \IteratorAggregate, \ArrayAccess,
{ {
if ($this->records === null) { if ($this->records === null) {
// todo: load only one record // todo: load only one record
$this->records = $this->findRecords(); $this->records = $this->findRecords(false);
} }
return isset($this->records[0]) ? $this->records[0] : null; return isset($this->records[0]) ? $this->records[0] : null;
} }
@ -276,178 +295,13 @@ class ActiveQuery extends BaseQuery implements \IteratorAggregate, \ArrayAccess,
unset($this->records[$offset]); unset($this->records[$offset]);
} }
public function joinWith() protected function findRecords($all = true)
{
// todo: inner join with one or multiple relations as filters
}
protected function findRecords()
{ {
$finder = new ActiveFinder($this->getDbConnection());
if (!empty($this->with)) { if (!empty($this->with)) {
// todo: handle findBySql() and limit cases return $finder->findRecordsWithRelations();
$joinTree = $this->buildRelationalQuery();
}
if ($this->sql === null) {
$this->initFrom($this->query);
$command = $this->query->createCommand($this->getDbConnection());
$this->sql = $command->getSql();
} else {
$command = $this->getDbConnection()->createCommand($this->sql);
$command->bindValues($this->query->params);
}
$rows = $command->queryAll();
if (isset($joinTree)) {
foreach ($rows as $row) {
$joinTree->populateData($row);
}
return array_values($joinTree->records);
}
if ($this->asArray) {
if ($this->indexBy === null) {
return $rows;
}
$records = array();
foreach ($rows as $row) {
$records[$row[$this->indexBy]] = $row;
}
return $records;
} else { } else {
$records = array(); return $finder->findRecords($this, $all);
$class = $this->modelClass;
if ($this->indexBy === null) {
foreach ($rows as $row) {
$records[] = $class::populateData($row);
}
} else {
$attribute = $this->indexBy;
foreach ($rows as $row) {
$record = $class::populateData($row);
$records[$record->$attribute] = $record;
}
}
return $records;
}
}
protected function initFrom($query)
{
if ($query->from === null) {
$modelClass = $this->modelClass;
$tableName = $modelClass::tableName();
if ($this->tableAlias !== null) {
$tableName .= ' ' . $this->tableAlias;
}
$query->from = array($tableName);
}
}
protected function buildRelationalQuery()
{
$joinTree = new JoinElement($this, null, null);
$this->buildJoinTree($joinTree, $this->with);
$this->buildTableAlias($joinTree);
$query = new Query;
foreach ($joinTree->children as $child) {
$child->buildQuery($query);
}
$select = $joinTree->buildSelect($this->query->select);
if (!empty($query->select)) {
$this->query->select = array_merge($select, $query->select);
} else {
$this->query->select = $select;
}
if (!empty($query->where)) {
$this->query->andWhere('(' . implode(') AND (', $query->where) . ')');
}
if (!empty($query->having)) {
$this->query->andHaving('(' . implode(') AND (', $query->having) . ')');
}
if (!empty($query->join)) {
if ($this->query->join === null) {
$this->query->join = $query->join;
} else {
$this->query->join = array_merge($this->query->join, $query->join);
}
}
if (!empty($query->orderBy)) {
$this->query->addOrderBy($query->orderBy);
}
if (!empty($query->groupBy)) {
$this->query->addGroupBy($query->groupBy);
}
if (!empty($query->params)) {
$this->query->addParams($query->params);
}
return $joinTree;
}
/**
* @param JoinElement $parent
* @param array|string $with
* @param array $config
* @return null|JoinElement
* @throws \yii\db\Exception
*/
protected function buildJoinTree($parent, $with, $config = array())
{
if (is_array($with)) {
foreach ($with as $name => $value) {
if (is_string($value)) {
$this->buildJoinTree($parent, $value);
} elseif (is_string($name) && is_array($value)) {
$this->buildJoinTree($parent, $name, $value);
}
}
return null;
}
if (($pos = strrpos($with, '.')) !== false) {
$parent = $this->buildJoinTree($parent, substr($with, 0, $pos));
$with = substr($with, $pos + 1);
}
if (isset($parent->children[$with])) {
$child = $parent->children[$with];
$child->joinOnly = false;
} else {
$modelClass = $parent->relation->modelClass;
$relations = $modelClass::getMetaData()->relations;
if (!isset($relations[$with])) {
throw new Exception("$modelClass has no relation named '$with'.");
}
$relation = clone $relations[$with];
if ($relation->via !== null && isset($relations[$relation->via])) {
$relation->via = null;
$parent2 = $this->buildJoinTree($parent, $relation->via);
if ($parent2->joinOnly === null) {
$parent2->joinOnly = true;
}
$child = new JoinElement($relation, $parent2, $parent);
} else {
$child = new JoinElement($relation, $parent, $parent);
}
}
foreach ($config as $name => $value) {
$child->relation->$name = $value;
}
return $child;
}
protected function buildTableAlias($element, &$count = 0)
{
if ($element->relation->tableAlias === null) {
$element->relation->tableAlias = 't' . ($count++);
}
foreach ($element->children as $child) {
$this->buildTableAlias($child, $count);
} }
} }
} }

15
framework/db/ar/ActiveRecord.php
Unescape View File

@ -427,7 +427,7 @@ abstract class ActiveRecord extends Model
if (array_key_exists($name, $this->_related)) { if (array_key_exists($name, $this->_related)) {
return $this->_related[$name]; return $this->_related[$name];
} else { } else {
return $this->_related[$name] = $this->loadRelatedRecord($md->relations[$name]); return $this->_related[$name] = $this->findByRelation($md->relations[$name]);
} }
} }
return parent::__get($name); return parent::__get($name);
@ -501,7 +501,7 @@ abstract class ActiveRecord extends Model
{ {
$md = $this->getMetaData(); $md = $this->getMetaData();
if (isset($md->relations[$name])) { if (isset($md->relations[$name])) {
return $this->loadRelatedRecord($md->relations[$name], isset($params[0]) ? $params[0] : array()); return $this->findByRelation($md->relations[$name], isset($params[0]) ? $params[0] : array());
} }
return parent::__call($name, $params); return parent::__call($name, $params);
} }
@ -532,14 +532,12 @@ abstract class ActiveRecord extends Model
* or null if the object does not exist. * or null if the object does not exist.
* If the relation is HAS_MANY or MANY_MANY, it will return an array of objects * If the relation is HAS_MANY or MANY_MANY, it will return an array of objects
* or an empty array. * or an empty array.
* @param string $name the relation name (see {@link relations}) * @param ActiveRelation|string $relation the relation object or the name of the relation
* @param boolean $refresh whether to reload the related objects from database. Defaults to false.
* @param array $params additional parameters that customize the query conditions as specified in the relation declaration. * @param array $params additional parameters that customize the query conditions as specified in the relation declaration.
* This parameter has been available since version 1.0.5.
* @return mixed the related object(s). * @return mixed the related object(s).
* @throws Exception if the relation is not specified in {@link relations}. * @throws Exception if the relation is not specified in [[relations()]].
*/ */
public function loadRelatedRecord($relation, $params = array()) public function findByRelation($relation, $params = array())
{ {
if (is_string($relation)) { if (is_string($relation)) {
$md = $this->getMetaData(); $md = $this->getMetaData();
@ -548,7 +546,8 @@ abstract class ActiveRecord extends Model
} }
$relation = $md->relations[$relation]; $relation = $md->relations[$relation];
} }
$finder = $this->createActiveQuery(); $query = $this->createActiveQuery();
return $query->findRelatedRecords($this, $relation, $params);
} }
/** /**

9
framework/db/ar/ActiveRelation.php
Unescape View File

@ -33,9 +33,10 @@ class ActiveRelation extends BaseQuery
*/ */
public $hasMany; public $hasMany;
/** /**
* @var string the join type (e.g. INNER JOIN, LEFT JOIN). Defaults to 'LEFT JOIN'. * @var string the join type (e.g. INNER JOIN, LEFT JOIN). Defaults to 'LEFT JOIN' when
* this relation is used to load related records, and 'INNER JOIN' when this relation is used as a filter.
*/ */
public $joinType = 'LEFT JOIN'; public $joinType;
/** /**
* @var string the table alias used for the corresponding table during query * @var string the table alias used for the corresponding table during query
*/ */
@ -58,6 +59,10 @@ class ActiveRelation extends BaseQuery
*/ */
public $with; public $with;
/** /**
* @var array the relations that should be used as filters for this query
*/
public $filters;
/**
* @var array the scopes that should be applied during query * @var array the scopes that should be applied during query
*/ */
public $scopes; public $scopes;

52
tests/unit/framework/db/ar/ActiveRecordTest.php
Unescape View File

@ -3,7 +3,7 @@
namespace yiiunit\framework\db\ar; namespace yiiunit\framework\db\ar;
use yii\db\dao\Query; use yii\db\dao\Query;
use yii\db\ar\ActiveFinder; use yii\db\ar\ActiveQuery;
use yiiunit\data\ar\ActiveRecord; use yiiunit\data\ar\ActiveRecord;
use yiiunit\data\ar\Customer; use yiiunit\data\ar\Customer;
use yiiunit\data\ar\OrderItem; use yiiunit\data\ar\OrderItem;
@ -45,28 +45,14 @@ class ActiveRecordTest extends \yiiunit\MysqlTestCase
$customer2 = Customer::find(2)->one(); $customer2 = Customer::find(2)->one();
$this->assertEquals('user2x', $customer2->name); $this->assertEquals('user2x', $customer2->name);
// saveAttributes // updateCounters
$customer = Customer::find(1)->one();
$this->assertEquals('user1', $customer->name);
$this->assertEquals('address1', $customer->address);
$customer->saveAttributes(array(
'name' => 'user1x',
'address' => 'address1x',
));
$this->assertEquals('user1x', $customer->name);
$this->assertEquals('address1x', $customer->address);
$customer = Customer::find(1)->one();
$this->assertEquals('user1x', $customer->name);
$this->assertEquals('address1x', $customer->address);
// saveCounters
$pk = array('order_id' => 2, 'item_id' => 4); $pk = array('order_id' => 2, 'item_id' => 4);
$orderItem = OrderItem::find($pk)->one(); $orderItem = OrderItem::find()->where($pk)->one();
$this->assertEquals(1, $orderItem->quantity); $this->assertEquals(1, $orderItem->quantity);
$ret = $orderItem->saveCounters(array('quantity' => -1)); $ret = $orderItem->updateCounters(array('quantity' => -1));
$this->assertTrue($ret); $this->assertTrue($ret);
$this->assertEquals(0, $orderItem->quantity); $this->assertEquals(0, $orderItem->quantity);
$orderItem = OrderItem::find($pk)->one(); $orderItem = OrderItem::find()->where($pk)->one();
$this->assertEquals(0, $orderItem->quantity); $this->assertEquals(0, $orderItem->quantity);
// updateAll // updateAll
@ -81,13 +67,13 @@ class ActiveRecordTest extends \yiiunit\MysqlTestCase
// updateCounters // updateCounters
$pk = array('order_id' => 1, 'item_id' => 2); $pk = array('order_id' => 1, 'item_id' => 2);
$orderItem = OrderItem::find($pk)->one(); $orderItem = OrderItem::find()->where($pk)->one();
$this->assertEquals(2, $orderItem->quantity); $this->assertEquals(2, $orderItem->quantity);
$ret = OrderItem::updateCounters(array( $ret = OrderItem::updateAllCounters(array(
'quantity' => 3, 'quantity' => 3,
), $pk); ), $pk);
$this->assertEquals(1, $ret); $this->assertEquals(1, $ret);
$orderItem = OrderItem::find($pk)->one(); $orderItem = OrderItem::find()->where($pk)->one();
$this->assertEquals(5, $orderItem->quantity); $this->assertEquals(5, $orderItem->quantity);
} }
@ -114,7 +100,7 @@ class ActiveRecordTest extends \yiiunit\MysqlTestCase
{ {
// find one // find one
$result = Customer::find(); $result = Customer::find();
$this->assertTrue($result instanceof ActiveFinder); $this->assertTrue($result instanceof ActiveQuery);
$customer = $result->one(); $customer = $result->one();
$this->assertTrue($customer instanceof Customer); $this->assertTrue($customer instanceof Customer);
$this->assertEquals(1, $result->count); $this->assertEquals(1, $result->count);
@ -158,13 +144,15 @@ class ActiveRecordTest extends \yiiunit\MysqlTestCase
$this->assertEquals('user2', $customer->name); $this->assertEquals('user2', $customer->name);
// find by attributes // find by attributes
$customer = Customer::find(array('name' => 'user2'))->one(); $customer = Customer::find()->where(array('name' => 'user2'))->one();
$this->assertTrue($customer instanceof Customer); $this->assertTrue($customer instanceof Customer);
$this->assertEquals(2, $customer->id); $this->assertEquals(2, $customer->id);
// find by Query // find by Query
$query = new Query; $query = array(
$query->where('id=:id', array(':id' => 2)); 'where' => 'id=:id',
'params' => array(':id' => 2),
);
$customer = Customer::find($query)->one(); $customer = Customer::find($query)->one();
$this->assertTrue($customer instanceof Customer); $this->assertTrue($customer instanceof Customer);
$this->assertEquals('user2', $customer->name); $this->assertEquals('user2', $customer->name);
@ -190,16 +178,16 @@ class ActiveRecordTest extends \yiiunit\MysqlTestCase
$this->assertEquals('user2', $customer->name); $this->assertEquals('user2', $customer->name);
// count // count
$finder = Customer::findBySql('SELECT * FROM tbl_customer ORDER BY id DESC'); $query = Customer::findBySql('SELECT * FROM tbl_customer ORDER BY id DESC');
$finder->one(); $query->one();
$this->assertEquals(3, $finder->count); $this->assertEquals(1, $query->count);
$finder = Customer::findBySql('SELECT * FROM tbl_customer ORDER BY id DESC'); $query = Customer::findBySql('SELECT * FROM tbl_customer ORDER BY id DESC');
$this->assertEquals(3, $finder->count); $this->assertEquals(3, $query->count);
} }
public function testQueryMethods() public function testQueryMethods()
{ {
$customer = Customer::find()->where('id=?', 2)->one(); $customer = Customer::find()->where('id=:id', array(':id' => 2))->one();
$this->assertTrue($customer instanceof Customer); $this->assertTrue($customer instanceof Customer);
$this->assertEquals('user2', $customer->name); $this->assertEquals('user2', $customer->name);

Write Preview
Loading…
Cancel
Save