HumHub Documentation (unofficial)

ActiveQueryInterface extends QueryInterface
in

ActiveQueryInterface defines the common interface to be implemented by active record query classes.

That are methods for either normal queries that return active records but also relational queries in which the query represents a relation between two active record classes and will return related records only.

A class implementing this interface should also use [[ActiveQueryTrait]] and [[ActiveRelationTrait]].

Tags
author

Qiang Xue qiang.xue@gmail.com

author

Carsten Brandt mail@cebe.cc

since
2.0

Table of Contents

Methods

addOrderBy()  : $this
Adds additional ORDER BY columns to the query.
all()  : array<string|int, mixed>
Executes the query and returns all results as an array.
andFilterWhere()  : $this
Adds an additional WHERE condition to the existing one ignoring empty parameters.
andWhere()  : $this
Adds an additional WHERE condition to the existing one.
asArray()  : $this
Sets the [[asArray]] property.
count()  : int|string|null
Returns the number of records.
emulateExecution()  : $this
Sets whether to emulate query execution, preventing any interaction with data storage.
exists()  : bool
Returns a value indicating whether the query result contains any row of data.
filterWhere()  : $this
Sets the WHERE part of the query ignoring empty parameters.
findFor()  : mixed
Finds the related records for the specified primary record.
indexBy()  : $this
Sets the [[indexBy]] property.
limit()  : $this
Sets the LIMIT part of the query.
offset()  : $this
Sets the OFFSET part of the query.
one()  : ActiveRecordInterface|array<string|int, mixed>|null
Executes query and returns a single row of result.
orderBy()  : $this
Sets the ORDER BY part of the query.
orFilterWhere()  : $this
Adds an additional WHERE condition to the existing one ignoring empty parameters.
orWhere()  : $this
Adds an additional WHERE condition to the existing one.
via()  : $this
Specifies the relation associated with the junction table for use in relational query.
where()  : $this
Sets the WHERE part of the query.
with()  : $this
Specifies the relations with which this query should be performed.

Methods

addOrderBy()

Adds additional ORDER BY columns to the query.

public addOrderBy(string|array<string|int, mixed> $columns) : $this
Parameters
$columns : string|array<string|int, mixed>

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).

Tags
see
orderBy()
Return values
$this —

the query object itself

all()

Executes the query and returns all results as an array.

public all([Connection|null $db = null ]) : array<string|int, mixed>
Parameters
$db : Connection|null = null

the database connection used to execute the query. If this parameter is not given, the db application component will be used.

Return values
array<string|int, mixed> —

the query results. If the query results in nothing, an empty array will be returned.

andFilterWhere()

Adds an additional WHERE condition to the existing one ignoring empty parameters.

public andFilterWhere(array<string|int, mixed> $condition) : $this

The new condition and the existing one will be joined using the 'AND' operator.

Parameters
$condition : array<string|int, mixed>

the new WHERE condition. Please refer to [[where()]] on how to specify this parameter.

Tags
see
filterWhere()
see
orFilterWhere()
Return values
$this —

the query object itself

andWhere()

Adds an additional WHERE condition to the existing one.

public andWhere(array<string|int, mixed> $condition) : $this

The new condition and the existing one will be joined using the 'AND' operator.

Parameters
$condition : array<string|int, mixed>

the new WHERE condition. Please refer to [[where()]] on how to specify this parameter.

Tags
see
where()
see
orWhere()
Return values
$this —

the query object itself

asArray()

Sets the [[asArray]] property.

public asArray([bool $value = true ]) : $this
Parameters
$value : bool = true

whether to return the query results in terms of arrays instead of Active Records.

Return values
$this —

the query object itself

count()

Returns the number of records.

public count([string $q = '*' ][, Connection|null $db = null ]) : int|string|null
Parameters
$q : string = '*'

the COUNT expression. Defaults to '*'.

$db : Connection|null = null

the database connection used to execute the query. If this parameter is not given, the db application component will be used.

Return values
int|string|null —

number of records.

emulateExecution()

Sets whether to emulate query execution, preventing any interaction with data storage.

public emulateExecution([bool $value = true ]) : $this

After this mode is enabled, methods, returning query results like [[one()]], [[all()]], [[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.

Parameters
$value : bool = true

whether to prevent query execution.

Tags
since
2.0.11
Return values
$this —

the query object itself.

exists()

Returns a value indicating whether the query result contains any row of data.

public exists([Connection|null $db = null ]) : bool
Parameters
$db : Connection|null = null

the database connection used to execute the query. If this parameter is not given, the db application component will be used.

Return values
bool —

whether the query result contains any row of data.

filterWhere()

Sets the WHERE part of the query ignoring empty parameters.

public filterWhere(array<string|int, mixed> $condition) : $this
Parameters
$condition : array<string|int, mixed>

the conditions that should be put in the WHERE part. Please refer to [[where()]] on how to specify this parameter.

Tags
see
andFilterWhere()
see
orFilterWhere()
Return values
$this —

the query object itself

findFor()

Finds the related records for the specified primary record.

public findFor(string $name, ActiveRecordInterface $model) : mixed

This method is invoked when a relation of an ActiveRecord is being accessed in a lazy fashion.

Parameters
$name : string

the relation name

$model : ActiveRecordInterface

the primary model

Return values
mixed —

the related record(s)

indexBy()

Sets the [[indexBy]] property.

public indexBy(string|callable $column) : $this
Parameters
$column : string|callable

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 values
$this —

the query object itself

limit()

Sets the LIMIT part of the query.

public limit(int|null $limit) : $this
Parameters
$limit : int|null

the limit. Use null or negative value to disable limit.

Return values
$this —

the query object itself

offset()

Sets the OFFSET part of the query.

public offset(int|null $offset) : $this
Parameters
$offset : int|null

the offset. Use null or negative value to disable offset.

Return values
$this —

the query object itself

one()

Executes query and returns a single row of result.

public one([Connection|null $db = null ]) : ActiveRecordInterface|array<string|int, mixed>|null
Parameters
$db : Connection|null = null

the DB connection used to create the DB command. If null, the DB connection returned by [[ActiveQueryTrait::$modelClass|modelClass]] will be used.

Return values
ActiveRecordInterface|array<string|int, mixed>|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 if the query results in nothing.

orderBy()

Sets the ORDER BY part of the query.

public orderBy(string|array<string|int, mixed> $columns) : $this
Parameters
$columns : string|array<string|int, mixed>

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).

Tags
see
addOrderBy()
Return values
$this —

the query object itself

orFilterWhere()

Adds an additional WHERE condition to the existing one ignoring empty parameters.

public orFilterWhere(array<string|int, mixed> $condition) : $this

The new condition and the existing one will be joined using the 'OR' operator.

Parameters
$condition : array<string|int, mixed>

the new WHERE condition. Please refer to [[where()]] on how to specify this parameter.

Tags
see
filterWhere()
see
andFilterWhere()
Return values
$this —

the query object itself

orWhere()

Adds an additional WHERE condition to the existing one.

public orWhere(array<string|int, mixed> $condition) : $this

The new condition and the existing one will be joined using the 'OR' operator.

Parameters
$condition : array<string|int, mixed>

the new WHERE condition. Please refer to [[where()]] on how to specify this parameter.

Tags
see
where()
see
andWhere()
Return values
$this —

the query object itself

via()

Specifies the relation associated with the junction table for use in relational query.

public via(string $relationName[, callable|null $callable = null ]) : $this
Parameters
$relationName : string

the relation name. This refers to a relation declared in the [[ActiveRelationTrait::primaryModel|primaryModel]] of the relation.

$callable : callable|null = null

a PHP callback for customizing the relation associated with the junction table. Its signature should be function($query), where $query is the query to be customized.

Return values
$this —

the relation object itself.

where()

Sets the WHERE part of the query.

public where(array<string|int, mixed> $condition) : $this

The $condition specified as an array can be 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 following:

  • 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. For example, ['or', ['type' => [7, 8, 9]], ['id' => [1, 2, 3]]] will generate (type IN (7, 8, 9) OR (id IN (1, 2, 3))).

  • not: this will take only one operand and build the negation of it by prefixing the query string with NOT. For example ['not', ['attribute' => null]] will result in the condition NOT (attribute IS NULL).

  • 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.

    To create a composite IN condition you can use and array for the column name and value, where the values are indexed by the column name: ['in', ['id', 'name'], [['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'bar']] ].

    You may also specify a sub-query that is used to get the values for the IN-condition: ['in', 'user_id', (new Query())->select('id')->from('users')->where(['active' => 1])]

  • 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 special characters in the values. Sometimes, you may want to add the percentage characters to the matching value by yourself, you may supply a third operand false to do so. For example, ['like', 'name', '%tester', false] will generate name LIKE '%tester'.

  • 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.

  • exists: operand 1 is a query object that used to build an EXISTS condition. For example ['exists', (new Query())->select('id')->from('users')->where(['active' => 1])] will result in the following SQL expression: EXISTS (SELECT "id" FROM "users" WHERE "active"=1).

  • not exists: similar to the exists operator except that EXISTS is replaced with NOT EXISTS in the generated condition.

  • Additionally you can specify arbitrary operators as follows: A condition of ['>=', 'id', 10] will result in the following SQL expression: id >= 10.

Note that this method will override any existing WHERE condition. You might want to use [[andWhere()]] or [[orWhere()]] instead.

Parameters
$condition : array<string|int, mixed>

the conditions that should be put in the WHERE part.

Tags
see
andWhere()
see
orWhere()
Return values
$this —

the query object itself

with()

Specifies the relations with which this query should be performed.

public with() : $this

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.

A relation name can refer to a relation defined in [[ActiveQueryTrait::modelClass|modelClass]] or a sub-relation that stands for a relation of a related record. For example, orders.address means the address relation defined in the model class corresponding to the orders relation.

The following are some usage examples:

// find customers together with their orders and country
Customer::find()->with('orders', 'country')->all();
// find customers together with their orders and the orders' shipping address
Customer::find()->with('orders.address')->all();
// find customers together with their country and orders of status 1
Customer::find()->with([
    'orders' => function (\yii\db\ActiveQuery $query) {
        $query->andWhere('status = 1');
    },
    'country',
])->all();
Return values
$this —

the query object itself


        

        
    




    

    

                                

                

                            
    

        On this page

        
    


                

                            

            

    

        

            
Search results