Interface Yiisoft\ActiveRecord\ActiveQueryInterface

Define an alias for the table defined in {@see ActiveRecordInterface}.

This method will adjust {@see \Yiisoft\ActiveRecord\from()} so that an already defined alias will be overwritten.

If none was defined, {@see \Yiisoft\ActiveRecord\from()} will be populated with the given alias.

Adds ON condition to the existing one.

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

See also:

• on()
• orOn()

Sets the {@see asArray} property.

Finds an ActiveRecord instance by the given primary key value.

In the examples below, the id column is the primary key of the table.

$customerQuery = Customer::query();

$customer = $customerQuery->findByPk(1); // WHERE id = 1

$customer = $customerQuery->findByPk([1]); // WHERE id = 1

In the examples below, the id and id2 columns are the composite primary key of the table.

$orderItemQuery = OrderItem::query();

$orderItem = $orderItemQuery->findByPk([1, 2]); // WHERE id = 1 AND id2 = 2

If you need to pass user input to this method, make sure the input value is scalar or in case of array, make sure the array values are scalar:

public function actionView(ServerRequestInterface $request)
{
    $id = (string) $request->getAttribute('id');

    $customerQuery = Customer::query();
    $customer = $customerQuery->findByPk($id);
}

See also on().

Returns table names used in {@see from} indexed by aliases.

Both aliases and names are enclosed into {{ and }}.

See also via().

Inner joins with the specified relations.

This is a shortcut method to {@see \Yiisoft\ActiveRecord\joinWith()} with the join type set as "INNER JOIN".

Please refer to {@see \Yiisoft\ActiveRecord\joinWith()} for detailed usage of this method.

See also joinWith().

Sets the name of the relation that is the inverse of this relation.

For example, a customer has orders, which means the inverse of the "orders" relation is the "customer".

If this property is set, the primary record(s) will be referenced through the specified relation.

For example, $customer->orders[0]->customer and $customer will be the same object, and accessing the customer of an order will not trigger a new DB query.

Use this method when declaring a relation in the {@see \Yiisoft\ActiveRecord\ActiveRecord} class, e.g., in the Customer model:

public function getOrdersQuery()
{
    return $this->hasMany(Order::class, ['customer_id' => 'id'])->inverseOf('customer');
}

This also may be used for the Order model, but with caution:

public function getCustomerQuery()
{
    return $this->hasOne(Customer::class, ['id' => 'customer_id'])->inverseOf('orders');
}

in this case result will depend on how order(s) was loaded. Let's suppose customer has several orders. If only one order was loaded:

$orders = Order::query()->where(['id' => 1])->all();
$customerOrders = $orders[0]->customer->orders;

variable $customerOrders will contain only one order. If orders was loaded like this:

$orders = Order::query()->with('customer')->where(['customer_id' => 1])->all();
$customerOrders = $orders[0]->customer->orders;

variable $customerOrders will contain all orders of the customer.

Returns a value indicating whether the query result rows should be returned as arrays instead of Active Record models.

Joins with the specified relations.

This method allows you to reuse existing relation definitions to perform JOIN queries. Based on the definition of the specified relation(s), the method will append one or many JOIN statements to the current query.

If the $eagerLoading parameter is true, the method will also perform eager loading for the specified relations, which is equal to calling {@see \Yiisoft\ActiveRecord\with()} using the specified relations.

Note: That because a JOIN query will be performed, you're responsible for disambiguated column names.

This method differs from {@see \Yiisoft\ActiveRecord\with()} in that it will build up and execute a JOIN SQL statement for the primary table. And when $eagerLoading is true, it will call {@see \Yiisoft\ActiveRecord\with()} also with the specified relations.

Note: Relations specified in $with cannot have GROUP BY, HAVING, or UNION clauses. Using these clauses will result in a {@see \LogicException}.

It's used to set the query options for the query.

It's used to set the query options for the query.

Sets the ON condition for a relational query.

The condition will be used in the ON part when {@see \Yiisoft\ActiveRecord\joinWith()} is called.

Otherwise, the condition will be used in the WHERE part of a query.

Use this method to specify more conditions when declaring a relation in the {@see \Yiisoft\ActiveRecord\ActiveRecord} class:

public function getActiveUsers(): ActiveQuery
{
    return $this->hasMany(User::class, ['id' => 'user_id'])->onCondition(['active' => true]);
}

Note that this condition is applied in case of a join as well as when fetching the related records. These only fields of the related table can be used in the condition. Trying to access fields of the primary record will cause an error in a non-join-query.

Adds ON condition to the existing one.

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

See also:

• on()
• andOn()

Converts the raw query results into the format as specified by this query.

This method is internally used to convert the data fetched from a database into the format as required by this query.

Finds the related records and populates them into the primary models.

It's used to set the query options for the query.

Returns related record(s).

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

Resets the relations that this query should be performed with.

This method clears all relations set via {@see \Yiisoft\ActiveRecord\with()} and disables eager loading for relations set via {@see \Yiisoft\ActiveRecord\joinWith()}, while keeping the JOIN clauses intact.

Specifies the relation associated with the junction table.

Use this method to specify a pivot record/table when declaring a relation in the {@see \Yiisoft\ActiveRecord\ActiveRecord} class:

class Order extends ActiveRecord
{
   public function getOrderItems() {
       return $this->hasMany(OrderItem::class, ['order_id' => 'id']);
   }

   public function getItems() {
       return $this->hasMany(Item::class, ['id' => 'item_id'])->via('orderItems');
   }
}

Specifies the junction table for a relational query.

Use this method to specify a junction table when declaring a relation in the {@see \Yiisoft\ActiveRecord\ActiveRecord} class:

public function getItems()
{
    return $this->hasMany(Item::class, ['id' => 'item_id'])->viaTable('order_item', ['order_id' => 'id']);
}

See also via().

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.

A relation name can refer to a relation defined in {@see \Yiisoft\ActiveRecord\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::query()->with('orders', 'country')->all();
// find customers together with their orders and the orders' shipping address
Customer::query()->with('orders.address')->all();
// find customers together with their country and orders of status 1
Customer::query()->with([
    'orders' => function (ActiveQuery $query) {
        $query->andWhere('status = 1');
    },
    'country',
])->all();

You can call with() multiple times. Each call will add relations to the existing ones.

For example, the following two statements are equivalent:

Customer::query()->with('orders', 'country')->all();
Customer::query()->with('orders')->with('country')->all();