The BaseQuery trait represents the minimum method set of a database Query.
It is supposed to be used in a class that implements the yii\db\QueryInterface.
Property DetailsWhether to emulate the actual query execution, returning empty or false results.
See also emulateExecution().
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().
Maximum number of records to be returned. May be an instance of yii\db\ExpressionInterface. If not set or less than 0, it means no limit.
Zero-based offset from where the records are to be returned. May be an instance of yii\db\ExpressionInterface. If not set or less than 0, it means starting from the beginning.
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 SORT_ASC or SORT_DESC. The array may also contain yii\db\ExpressionInterface objects. If that is the case, the expressions will be converted into strings without any change.
Query condition. This refers to the WHERE clause in a SQL statement. For example, ['age' => 31, 'team' => 1].
See also where() for valid syntax on specifying this value.
Method DetailsAdds additional ORDER BY columns to the query.
See also orderBy().
public $this addOrderBy ( $columns ) $columns string|array|yii\db\ExpressionInterfaceThe 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' => SORT_ASC, 'name' => SORT_DESC]).
The method will automatically quote the column names unless a column contains some parenthesis (which means the column contains a DB expression).
Note that if your order-by is an expression containing commas, you should always use an array to represent the order-by information. Otherwise, the method will not be able to correctly determine the order-by columns.
Since version 2.0.7, an yii\db\ExpressionInterface object can be passed to specify the ORDER BY part explicitly in plain SQL.
return $thisThe query object itself
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;
}
Adds an additional WHERE condition to the existing one but ignores empty operands.
The new condition and the existing one will be joined using the 'AND' operator.
This method is similar to andWhere(). The main difference is that this method will remove empty query operands. As a result, this method is best suited for building query conditions based on filter values entered by users.
See also:
public function andFilterWhere(array $condition)
{
$condition = $this->filterCondition($condition);
if ($condition !== []) {
$this->andWhere($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.
See also:
public function andWhere($condition)
{
if ($this->where === null) {
$this->where = $condition;
} else {
$this->where = ['and', $this->where, $condition];
}
return $this;
}
Sets whether to emulate query execution, preventing any interaction with data storage.
After this mode is enabled, methods, returning query results like yii\db\QueryInterface::one(), yii\db\QueryInterface::all(), yii\db\QueryInterface::exists() and so on, will return empty or false values. You should use this method in case your program logic indicates query should not return any results, like in case you set false where condition like 0=1.
public function emulateExecution($value = true)
{
$this->emulateExecution = $value;
return $this;
}
Removes empty operands from the given query condition.
protected function filterCondition($condition)
{
if (!is_array($condition)) {
return $condition;
}
if (!isset($condition[0])) {
foreach ($condition as $name => $value) {
if ($this->isEmpty($value)) {
unset($condition[$name]);
}
}
return $condition;
}
$operator = array_shift($condition);
switch (strtoupper($operator)) {
case 'NOT':
case 'AND':
case 'OR':
foreach ($condition as $i => $operand) {
$subCondition = $this->filterCondition($operand);
if ($this->isEmpty($subCondition)) {
unset($condition[$i]);
} else {
$condition[$i] = $subCondition;
}
}
if (empty($condition)) {
return [];
}
break;
case 'BETWEEN':
case 'NOT BETWEEN':
if (array_key_exists(1, $condition) && array_key_exists(2, $condition)) {
if ($this->isEmpty($condition[1]) || $this->isEmpty($condition[2])) {
return [];
}
}
break;
default:
if (array_key_exists(1, $condition) && $this->isEmpty($condition[1])) {
return [];
}
}
array_unshift($condition, $operator);
return $condition;
}
Sets the WHERE part of the query but ignores empty operands.
This method is similar to where(). The main difference is that this method will remove empty query operands. As a result, this method is best suited for building query conditions based on filter values entered by users.
The following code shows the difference between this method and where():
$query->filterWhere(['name' => null, 'age' => 20]);
$query->where(['age' => 20]);
$query->where(['name' => null, 'age' => 20]);
Note that unlike where(), you cannot pass binding parameters to this method.
See also:
public $this filterWhere ( array $condition ) $condition arrayThe conditions that should be put in the WHERE part. See where() on how to specify this parameter.
return $thisThe query object itself
public function filterWhere(array $condition)
{
$condition = $this->filterCondition($condition);
if ($condition !== []) {
$this->where($condition);
}
return $this;
}
Sets the indexBy() property.
public $this indexBy ( $column ) $column string|callableThe 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)
{
}
The query object itself
public function indexBy($column)
{
$this->indexBy = $column;
return $this;
}
Returns a value indicating whether the give value is "empty".
The value is considered "empty", if one of the following conditions is satisfied:
null,''), protected function isEmpty($value)
{
return $value === '' || $value === [] || $value === null || is_string($value) && trim($value) === '';
}
Sets the LIMIT part of the query.
public function limit($limit)
{
$this->limit = $limit;
return $this;
}
Normalizes format of ORDER BY data.
protected function normalizeOrderBy($columns)
{
if (empty($columns)) {
return [];
} elseif ($columns instanceof ExpressionInterface) {
return [$columns];
} elseif (is_array($columns)) {
return $columns;
}
$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') ? SORT_ASC : SORT_DESC;
} else {
$result[$column] = SORT_ASC;
}
}
return $result;
}
Sets the OFFSET part of the query.
public function offset($offset)
{
$this->offset = $offset;
return $this;
}
Adds an additional WHERE condition to the existing one but ignores empty operands.
The new condition and the existing one will be joined using the 'OR' operator.
This method is similar to orWhere(). The main difference is that this method will remove empty query operands. As a result, this method is best suited for building query conditions based on filter values entered by users.
See also:
public function orFilterWhere(array $condition)
{
$condition = $this->filterCondition($condition);
if ($condition !== []) {
$this->orWhere($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.
See also:
public function orWhere($condition)
{
if ($this->where === null) {
$this->where = $condition;
} else {
$this->where = ['or', $this->where, $condition];
}
return $this;
}
public $this orderBy ( $columns ) $columns string|array|yii\db\ExpressionInterface|null
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' => SORT_ASC, 'name' => SORT_DESC]).
The method will automatically quote the column names unless a column contains some parenthesis (which means the column contains a DB expression).
Note that if your order-by is an expression containing commas, you should always use an array to represent the order-by information. Otherwise, the method will not be able to correctly determine the order-by columns.
Since version 2.0.7, an yii\db\ExpressionInterface object can be passed to specify the ORDER BY part explicitly in plain SQL.
return $thisThe query object itself
public function orderBy($columns)
{
$this->orderBy = $this->normalizeOrderBy($columns);
return $this;
}
public function where($condition)
{
$this->where = $condition;
return $this;
}
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4