Carsten Brandt
11 years ago
6 changed files with 792 additions and 531 deletions
@ -0,0 +1,234 @@
|
||||
<?php |
||||
/** |
||||
* @link http://www.yiiframework.com/ |
||||
* @copyright Copyright (c) 2008 Yii Software LLC |
||||
* @license http://www.yiiframework.com/license/ |
||||
*/ |
||||
|
||||
namespace yii\ar; |
||||
|
||||
use yii\db\ActiveRecord; |
||||
|
||||
/** |
||||
* 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. |
||||
* - [[scalar()]]: returns the value of the first column in the first row of the query result. |
||||
* - [[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: |
||||
* |
||||
* - [[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: |
||||
* |
||||
* ~~~ |
||||
* $customers = Customer::find()->with('orders')->asArray()->all(); |
||||
* ~~~ |
||||
* |
||||
* @author Qiang Xue <qiang.xue@gmail.com> |
||||
* @author Carsten Brandt <mail@cebe.cc> |
||||
* @since 2.0 |
||||
*/ |
||||
trait ActiveQuery |
||||
{ |
||||
/** |
||||
* @var string the name of the ActiveRecord class. |
||||
*/ |
||||
public $modelClass; |
||||
/** |
||||
* @var array list of relations that this query should be performed with |
||||
*/ |
||||
public $with; |
||||
/** |
||||
* @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; |
||||
|
||||
|
||||
/** |
||||
* 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); |
||||
call_user_func_array([$this->modelClass, $name], $params); |
||||
return $this; |
||||
} else { |
||||
return parent::__call($name, $params); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* 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 |
||||
*/ |
||||
public function asArray($value = true) |
||||
{ |
||||
$this->asArray = $value; |
||||
return $this; |
||||
} |
||||
|
||||
/** |
||||
* 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([ |
||||
* 'orders' => function($query) { |
||||
* $query->andWhere('status = 1'); |
||||
* }, |
||||
* 'country', |
||||
* ])->all(); |
||||
* ~~~ |
||||
* |
||||
* @return static the query object itself |
||||
*/ |
||||
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; |
||||
} |
||||
|
||||
/** |
||||
* 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 |
||||
*/ |
||||
public function indexBy($column) |
||||
{ |
||||
return parent::indexBy($column); |
||||
} |
||||
|
||||
private function createModels($rows) |
||||
{ |
||||
$models = []; |
||||
if ($this->asArray) { |
||||
if ($this->indexBy === null) { |
||||
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; |
||||
} |
||||
} else { |
||||
/** @var $class ActiveRecord */ |
||||
$class = $this->modelClass; |
||||
if ($this->indexBy === null) { |
||||
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; |
||||
} |
||||
} |
||||
} |
||||
return $models; |
||||
} |
||||
|
||||
private function populateRelations(&$models, $with) |
||||
{ |
||||
$primaryModel = new $this->modelClass; |
||||
$relations = $this->normalizeRelations($primaryModel, $with); |
||||
foreach ($relations as $name => $relation) { |
||||
if ($relation->asArray === null) { |
||||
// inherit asArray from primary query |
||||
$relation->asArray = $this->asArray; |
||||
} |
||||
$relation->findWith($name, $models); |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* @param ActiveRecord $model |
||||
* @param array $with |
||||
* @return ActiveRelation[] |
||||
*/ |
||||
private function normalizeRelations($model, $with) |
||||
{ |
||||
$relations = []; |
||||
foreach ($with as $name => $callback) { |
||||
if (is_integer($name)) { |
||||
$name = $callback; |
||||
$callback = null; |
||||
} |
||||
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; |
||||
} else { |
||||
$relation = $relations[$t]; |
||||
} |
||||
|
||||
if (isset($childName)) { |
||||
$relation->with[$childName] = $callback; |
||||
} elseif ($callback !== null) { |
||||
call_user_func($callback, $relation); |
||||
} |
||||
} |
||||
return $relations; |
||||
} |
||||
} |
||||
@ -0,0 +1,253 @@
|
||||
<?php |
||||
/** |
||||
* @link http://www.yiiframework.com/ |
||||
* @copyright Copyright (c) 2008 Yii Software LLC |
||||
* @license http://www.yiiframework.com/license/ |
||||
*/ |
||||
|
||||
namespace yii\ar; |
||||
|
||||
use yii\base\InvalidConfigException; |
||||
use yii\db\ActiveRecord; |
||||
|
||||
/** |
||||
* ActiveRelation represents a relation between two Active Record classes. |
||||
* |
||||
* ActiveRelation 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 ActiveRelation object. |
||||
* |
||||
* 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()]] or [[viaTable()]] method. |
||||
* |
||||
* @author Qiang Xue <qiang.xue@gmail.com> |
||||
* @since 2.0 |
||||
*/ |
||||
trait ActiveRelation |
||||
{ |
||||
/** |
||||
* @var boolean whether this relation should populate all query results into AR instances. |
||||
* If false, only the first row of the results will be retrieved. |
||||
*/ |
||||
public $multiple; |
||||
/** |
||||
* @var ActiveRecord the primary model that this relation is associated with. |
||||
* This is used only in lazy loading with dynamic query options. |
||||
*/ |
||||
public $primaryModel; |
||||
/** |
||||
* @var array the columns of the primary and foreign tables that establish the relation. |
||||
* The array keys must be columns of the table for this relation, and the array values |
||||
* must be the corresponding columns from the primary table. |
||||
* Do not prefix or quote the column names as they will be done automatically by Yii. |
||||
*/ |
||||
public $link; |
||||
/** |
||||
* @var array the query associated with the pivot table. Please call [[via()]] |
||||
* to set this property instead of directly setting it. |
||||
*/ |
||||
public $via; |
||||
|
||||
/** |
||||
* Clones internal objects. |
||||
*/ |
||||
public function __clone() |
||||
{ |
||||
if (is_object($this->via)) { |
||||
// make a clone of "via" object so that the same query object can be reused multiple times |
||||
$this->via = clone $this->via; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Specifies the relation associated with the pivot table. |
||||
* @param string $relationName the relation name. This refers to a relation declared in [[primaryModel]]. |
||||
* @param callable $callable a PHP callback for customizing the relation associated with the pivot table. |
||||
* Its signature should be `function($query)`, where `$query` is the query to be customized. |
||||
* @return static the relation object itself. |
||||
*/ |
||||
public function via($relationName, $callable = null) |
||||
{ |
||||
$relation = $this->primaryModel->getRelation($relationName); |
||||
$this->via = [$relationName, $relation]; |
||||
if ($callable !== null) { |
||||
call_user_func($callable, $relation); |
||||
} |
||||
return $this; |
||||
} |
||||
|
||||
/** |
||||
* Finds the related records and populates them into the primary models. |
||||
* This method is internally used by [[ActiveQuery]]. Do not call it directly. |
||||
* @param string $name the relation name |
||||
* @param array $primaryModels primary models |
||||
* @return array the related models |
||||
* @throws InvalidConfigException |
||||
*/ |
||||
public function findWith($name, &$primaryModels) |
||||
{ |
||||
if (!is_array($this->link)) { |
||||
throw new InvalidConfigException('Invalid link: it must be an array of key-value pairs.'); |
||||
} |
||||
|
||||
if ($this->via instanceof self) { |
||||
// via pivot table |
||||
/** @var $viaQuery ActiveRelation */ |
||||
$viaQuery = $this->via; |
||||
$viaModels = $viaQuery->findPivotRows($primaryModels); |
||||
$this->filterByModels($viaModels); |
||||
} elseif (is_array($this->via)) { |
||||
// via relation |
||||
/** @var $viaQuery ActiveRelation */ |
||||
list($viaName, $viaQuery) = $this->via; |
||||
$viaQuery->primaryModel = null; |
||||
$viaModels = $viaQuery->findWith($viaName, $primaryModels); |
||||
$this->filterByModels($viaModels); |
||||
} else { |
||||
$this->filterByModels($primaryModels); |
||||
} |
||||
|
||||
if (count($primaryModels) === 1 && !$this->multiple) { |
||||
$model = $this->one(); |
||||
foreach ($primaryModels as $i => $primaryModel) { |
||||
if ($primaryModel instanceof ActiveRecord) { |
||||
$primaryModel->populateRelation($name, $model); |
||||
} else { |
||||
$primaryModels[$i][$name] = $model; |
||||
} |
||||
} |
||||
return [$model]; |
||||
} else { |
||||
$models = $this->all(); |
||||
if (isset($viaModels, $viaQuery)) { |
||||
$buckets = $this->buildBuckets($models, $this->link, $viaModels, $viaQuery->link); |
||||
} else { |
||||
$buckets = $this->buildBuckets($models, $this->link); |
||||
} |
||||
|
||||
$link = array_values(isset($viaQuery) ? $viaQuery->link : $this->link); |
||||
foreach ($primaryModels as $i => $primaryModel) { |
||||
$key = $this->getModelKey($primaryModel, $link); |
||||
$value = isset($buckets[$key]) ? $buckets[$key] : ($this->multiple ? [] : null); |
||||
if ($primaryModel instanceof ActiveRecord) { |
||||
$primaryModel->populateRelation($name, $value); |
||||
} else { |
||||
$primaryModels[$i][$name] = $value; |
||||
} |
||||
} |
||||
return $models; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* @param array $models |
||||
* @param array $link |
||||
* @param array $viaModels |
||||
* @param array $viaLink |
||||
* @return array |
||||
*/ |
||||
private function buildBuckets($models, $link, $viaModels = null, $viaLink = null) |
||||
{ |
||||
$buckets = []; |
||||
$linkKeys = array_keys($link); |
||||
foreach ($models as $i => $model) { |
||||
$key = $this->getModelKey($model, $linkKeys); |
||||
if ($this->indexBy !== null) { |
||||
$buckets[$key][$i] = $model; |
||||
} else { |
||||
$buckets[$key][] = $model; |
||||
} |
||||
} |
||||
|
||||
if ($viaModels !== null) { |
||||
$viaBuckets = []; |
||||
$viaLinkKeys = array_keys($viaLink); |
||||
$linkValues = array_values($link); |
||||
foreach ($viaModels as $viaModel) { |
||||
$key1 = $this->getModelKey($viaModel, $viaLinkKeys); |
||||
$key2 = $this->getModelKey($viaModel, $linkValues); |
||||
if (isset($buckets[$key2])) { |
||||
foreach ($buckets[$key2] as $i => $bucket) { |
||||
if ($this->indexBy !== null) { |
||||
$viaBuckets[$key1][$i] = $bucket; |
||||
} else { |
||||
$viaBuckets[$key1][] = $bucket; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
$buckets = $viaBuckets; |
||||
} |
||||
|
||||
if (!$this->multiple) { |
||||
foreach ($buckets as $i => $bucket) { |
||||
$buckets[$i] = reset($bucket); |
||||
} |
||||
} |
||||
return $buckets; |
||||
} |
||||
|
||||
/** |
||||
* @param ActiveRecord|array $model |
||||
* @param array $attributes |
||||
* @return string |
||||
*/ |
||||
private function getModelKey($model, $attributes) |
||||
{ |
||||
if (count($attributes) > 1) { |
||||
$key = []; |
||||
foreach ($attributes as $attribute) { |
||||
$key[] = $model[$attribute]; |
||||
} |
||||
return serialize($key); |
||||
} else { |
||||
$attribute = reset($attributes); |
||||
return $model[$attribute]; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* @param array $models |
||||
*/ |
||||
private function filterByModels($models) |
||||
{ |
||||
$attributes = array_keys($this->link); |
||||
$values = []; |
||||
if (count($attributes) === 1) { |
||||
// single key |
||||
$attribute = reset($this->link); |
||||
foreach ($models as $model) { |
||||
if (($value = $model[$attribute]) !== null) { |
||||
$values[] = $value; |
||||
} |
||||
} |
||||
} else { |
||||
// composite keys |
||||
foreach ($models as $model) { |
||||
$v = []; |
||||
foreach ($this->link as $attribute => $link) { |
||||
$v[$attribute] = $model[$link]; |
||||
} |
||||
$values[] = $v; |
||||
} |
||||
} |
||||
$this->andWhere(['in', $attributes, array_unique($values, SORT_REGULAR)]); |
||||
} |
||||
|
||||
/** |
||||
* @param ActiveRecord[] $primaryModels |
||||
* @return array |
||||
*/ |
||||
private function findPivotRows($primaryModels) |
||||
{ |
||||
if (empty($primaryModels)) { |
||||
return []; |
||||
} |
||||
$this->filterByModels($primaryModels); |
||||
/** @var $primaryModel ActiveRecord */ |
||||
$primaryModel = reset($primaryModels); |
||||
return $this->asArray()->all($primaryModel->getDb()); |
||||
} |
||||
} |
||||
@ -0,0 +1,299 @@
|
||||
<?php |
||||
/** |
||||
* @link http://www.yiiframework.com/ |
||||
* @copyright Copyright (c) 2008 Yii Software LLC |
||||
* @license http://www.yiiframework.com/license/ |
||||
*/ |
||||
|
||||
namespace yii\db; |
||||
|
||||
// TODO where to put these constants? |
||||
/** |
||||
* Sort ascending |
||||
* @see orderBy |
||||
*/ |
||||
const SORT_ASC = false; |
||||
/** |
||||
* Sort descending |
||||
* @see orderBy |
||||
*/ |
||||
const SORT_DESC = true; |
||||
|
||||
/** |
||||
* The BaseQuery trait represents the minimum method set of a database Query. |
||||
* |
||||
* It has support for getting [[one]] instance or [[all]]. |
||||
* Allows pagination via [[limit]] and [[offset]]. |
||||
* Sorting is supported via [[orderBy]] and items can be limited to match some conditions unsing [[where]]. |
||||
* |
||||
* By calling [[createCommand()]], we can get a [[Command]] instance which can be further |
||||
* used to perform/execute the DB query against a database. |
||||
* |
||||
* @author Qiang Xue <qiang.xue@gmail.com> |
||||
* @author Carsten Brandt <mail@cebe.cc> |
||||
* @since 2.0 |
||||
*/ |
||||
trait BaseQuery |
||||
{ |
||||
/** |
||||
* @var string|array query condition. This refers to the WHERE clause in a SQL statement. |
||||
* For example, `age > 31 AND team = 1`. |
||||
* @see where() |
||||
*/ |
||||
public $where; |
||||
/** |
||||
* @var integer maximum number of records to be returned. If not set or less than 0, it means no limit. |
||||
*/ |
||||
public $limit; |
||||
/** |
||||
* @var integer zero-based offset from where the records are to be returned. If not set or |
||||
* less than 0, it means starting from the beginning. |
||||
*/ |
||||
public $offset; |
||||
/** |
||||
* @var array how to sort the query results. This is used to construct the ORDER BY clause in a SQL statement. |
||||
* The array keys are the columns to be sorted by, and the array values are the corresponding sort directions which |
||||
* can be either [[Query::SORT_ASC]] or [[Query::SORT_DESC]]. The array may also contain [[Expression]] objects. |
||||
* If that is the case, the expressions will be converted into strings without any change. |
||||
*/ |
||||
public $orderBy; |
||||
/** |
||||
* @var 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 data. For more details, see [[indexBy()]]. This property is only used by [[all()]]. |
||||
*/ |
||||
public $indexBy; |
||||
|
||||
/** |
||||
* 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 data. The signature of the callable should be: |
||||
* |
||||
* ~~~ |
||||
* function ($row) |
||||
* { |
||||
* // return the index value corresponding to $row |
||||
* } |
||||
* ~~~ |
||||
* |
||||
* @return static the query object itself |
||||
*/ |
||||
public function indexBy($column) |
||||
{ |
||||
$this->indexBy = $column; |
||||
return $this; |
||||
} |
||||
|
||||
/** |
||||
* Executes the 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. |
||||
*/ |
||||
abstract public function all(); |
||||
|
||||
/** |
||||
* Executes the query and returns a single row of result. |
||||
* @return array|boolean the first row (in terms of an array) of the query result. False is returned if the query |
||||
* results in nothing. |
||||
*/ |
||||
abstract public function one(); |
||||
|
||||
/** |
||||
* Returns the number of records. |
||||
* @return integer number of records |
||||
*/ |
||||
abstract public function count(); |
||||
|
||||
/** |
||||
* Returns a value indicating whether the query result contains any row of data. |
||||
* @return boolean whether the query result contains any row of data. |
||||
*/ |
||||
abstract public function exists(); |
||||
|
||||
/** |
||||
* Sets the WHERE part of the query. |
||||
* |
||||
* The method requires a $condition parameter. |
||||
* |
||||
* The $condition parameter should be an array in one of the following two formats: |
||||
* |
||||
* - hash format: `['column1' => value1, 'column2' => value2, ...]` |
||||
* - operator format: `[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: |
||||
* |
||||
* - `['type' => 1, 'status' => 2]` generates `(type = 1) AND (status = 2)`. |
||||
* - `['id' => [1, 2, 3], 'status' => 2]` generates `(id IN (1, 2, 3)) AND (status = 2)`. |
||||
* - `['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, |
||||
* `['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, |
||||
* `['and', 'type=1', ['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, `['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, |
||||
* `['in', 'id', [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, `['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, `['like', 'name', ['%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 array $condition the conditions that should be put in the WHERE part. |
||||
* @return static the query object itself |
||||
* @see andWhere() |
||||
* @see orWhere() |
||||
*/ |
||||
public function where($condition) |
||||
{ |
||||
$this->where = $condition; |
||||
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. |
||||
* @return static the query object itself |
||||
* @see where() |
||||
* @see orWhere() |
||||
*/ |
||||
public function andWhere($condition) |
||||
{ |
||||
if ($this->where === null) { |
||||
$this->where = $condition; |
||||
} else { |
||||
$this->where = ['and', $this->where, $condition]; |
||||
} |
||||
return $this; |
||||
} |
||||
|
||||
/** |
||||
* 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. |
||||
* @return static the query object itself |
||||
* @see where() |
||||
* @see andWhere() |
||||
*/ |
||||
public function orWhere($condition) |
||||
{ |
||||
if ($this->where === null) { |
||||
$this->where = $condition; |
||||
} else { |
||||
$this->where = ['or', $this->where, $condition]; |
||||
} |
||||
return $this; |
||||
} |
||||
|
||||
/** |
||||
* 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. `['id' => Query::SORT_ASC, 'name' => Query::SORT_DESC]`). |
||||
* The method will automatically quote the column names unless a column contains some parenthesis |
||||
* (which means the column contains a DB expression). |
||||
* @return static the query object itself |
||||
* @see addOrderBy() |
||||
*/ |
||||
public function orderBy($columns) |
||||
{ |
||||
$this->orderBy = $this->normalizeOrderBy($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. `['id' => Query::SORT_ASC, 'name' => Query::SORT_DESC]`). |
||||
* The method will automatically quote the column names unless a column contains some parenthesis |
||||
* (which means the column contains a DB expression). |
||||
* @return static the query object itself |
||||
* @see orderBy() |
||||
*/ |
||||
public function addOrderBy($columns) |
||||
{ |
||||
$columns = $this->normalizeOrderBy($columns); |
||||
if ($this->orderBy === null) { |
||||
$this->orderBy = $columns; |
||||
} else { |
||||
$this->orderBy = array_merge($this->orderBy, $columns); |
||||
} |
||||
return $this; |
||||
} |
||||
|
||||
protected function normalizeOrderBy($columns) |
||||
{ |
||||
if (is_array($columns)) { |
||||
return $columns; |
||||
} else { |
||||
$columns = preg_split('/\s*,\s*/', trim($columns), -1, PREG_SPLIT_NO_EMPTY); |
||||
$result = []; |
||||
foreach ($columns as $column) { |
||||
if (preg_match('/^(.*?)\s+(asc|desc)$/i', $column, $matches)) { |
||||
$result[$matches[1]] = strcasecmp($matches[2], 'desc') ? self::SORT_ASC : self::SORT_DESC; |
||||
} else { |
||||
$result[$column] = self::SORT_ASC; |
||||
} |
||||
} |
||||
return $result; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Sets the LIMIT part of the query. |
||||
* @param integer $limit the limit. Use null or negative value to disable limit. |
||||
* @return static the query object itself |
||||
*/ |
||||
public function limit($limit) |
||||
{ |
||||
$this->limit = $limit; |
||||
return $this; |
||||
} |
||||
|
||||
/** |
||||
* Sets the OFFSET part of the query. |
||||
* @param integer $offset the offset. Use null or negative value to disable offset. |
||||
* @return static the query object itself |
||||
*/ |
||||
public function offset($offset) |
||||
{ |
||||
$this->offset = $offset; |
||||
return $this; |
||||
} |
||||
} |
||||
Loading…
Reference in new issue