Yiisoft\ActiveRecord\ActiveQuery

Complexity

Total Complexity

118

Size/Duplication

Total Lines	859
Duplicated Lines	0 %

Test Coverage

Coverage

90.17%

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	getPrimaryTableName()	0	6	1
A	getJoinWith()	0	3	1
A	populate()	0	21	6
A	orOnCondition()	0	11	2
A	alias()	0	17	5
A	all()	0	3	1
A	getJoinType()	0	7	4
A	getTableNameAndAlias()	0	22	5
F	joinWithRelation()	0	79	18
A	getTablesUsedInFrom()	0	7	2
B	joinWithRelations()	0	50	10
A	innerJoinWith()	0	3	1
A	getModelClass()	0	3	1
A	andOnCondition()	0	11	2
A	one()	0	11	3
A	joinWith()	0	35	6
A	queryScalar()	0	17	2
A	viaTable()	0	13	3
B	buildJoinWith()	0	50	11
B	removeDuplicatedModels()	0	52	11
A	getOn()	0	3	1
A	createCommand()	0	17	2
C	prepare()	0	77	15
A	getSql()	0	3	1
A	onCondition()	0	6	1
A	__construct()	0	5	1
A	sql()	0	5	1
A	on()	0	5	1

<?php

declare(strict_types=1);

namespace Yiisoft\ActiveRecord;

use Yiisoft\Db\Command\Command;
use Yiisoft\Db\Exception\Exception;
use Yiisoft\Db\Exception\InvalidArgumentException;
use Yiisoft\Db\Exception\NotSupportedException;
use Yiisoft\Db\Query\Query;
use Yiisoft\Db\Exception\InvalidConfigException;

/**
 * ActiveQuery represents a DB query associated with an Active Record class.
 *
 * An ActiveQuery can be a normal query or be used in a relational context.
 *
 * ActiveQuery instances are usually created by {@see ActiveRecord::find()} and {@see ActiveRecord::findBySql()}.
 * Relational queries are created by {@see ActiveRecord::hasOne()} and {@see ActiveRecord::hasMany()}.
 *
 * Normal Query
 * ------------
 *
 * ActiveQuery mainly provides the following methods to retrieve the query results:
 *
 * - {@see one()}: returns a single record populated with the first row of data.
 * - {@see all()}: returns all records based on the query results.
 * - {@see count()}: returns the number of records.
 * - {@see sum()}: returns the sum over the specified column.
 * - {@see average()}: returns the average over the specified column.
 * - {@see min()}: returns the min over the specified column.
 * - {@see max()}: returns the max over the specified column.
 * - {@see scalar()}: returns the value of the first column in the first row of the query result.
 * - {@see column()}: returns the value of the first column in the query result.
 * - {@see exists()}: returns a value indicating whether the query result has data or not.
 *
 * Because ActiveQuery extends from {@see Query}, one can use query methods, such as {@see where()}, {@see orderBy()} to
 * customize the query options.
 *
 * ActiveQuery also provides the following additional query options:
 *
 * - {@see with()}: list of relations that this query should be performed with.
 * - {@see joinWith()}: reuse a relation query definition to add a join to a query.
 * - {@see indexBy()}: the name of the column by which the query result should be indexed.
 * - {@see asArray()}: whether to return each record as an array.
 *
 * These options can be configured using methods of the same name. For example:
 *
 * ```php
 * $customers = Customer::find()->with('orders')->asArray()->all();
 * ```
 *
 * Relational query
 * ----------------
 *
 * In relational context ActiveQuery represents a relation between two Active Record classes.
 *
 * Relational ActiveQuery instances are usually created by calling {@see ActiveRecord::hasOne()} and
 * {@see 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 ActiveQuery object.
 *
 * A relation is specified by {@see link} which represents the association between columns of different tables; and the
 * multiplicity of the relation is indicated by {@see multiple}.
 *
 * If a relation involves a junction table, it may be specified by {@see via()} or {@see viaTable()} method.
 * These methods may only be called in a relational context. Same is true for {@see inverseOf()}, which marks a relation
 * as inverse of another relation and {@see onCondition()} which adds a condition that is to be added to relational
 * query join condition.
 */
class ActiveQuery extends Query implements ActiveQueryInterface
{
    use ActiveQueryTrait;
    use ActiveRelationTrait;

    private ?string $modelClass;
    private ?string $sql = null;
    private $on;
    private array $joinWith = [];

    public function __construct(?string $modelClass)
    {
        $this->modelClass = $modelClass;

        parent::__construct($modelClass::getConnection());

The method getConnection() does not exist on null.

    }

    /**
     * Executes query and returns all results as an array.
     *
     * If null, the DB connection returned by {@see modelClass} will be used.
     *
     * @throws InvalidConfigException
     * @throws Exception
     * @throws InvalidArgumentException
     * @throws NotSupportedException
     *
     * @return array|ActiveRecord[] the query results. If the query results in nothing, an empty array will be returned.
     */
    public function all(): array
    {
        return parent::all();
    }

    public function prepare($builder): Query
    {
        /**
         * NOTE: because the same ActiveQuery may be used to build different SQL statements (e.g. by ActiveDataProvider,
         * one for count query, the other for row data query, it is important to make sure the same ActiveQuery can be
         * used to build SQL statements multiple times.
         */
        if (!empty($this->joinWith)) {
            $this->buildJoinWith();
            /** clean it up to avoid issue {@see https://github.com/yiisoft/yii2/issues/2687} */
            $this->joinWith = [];
        }

        if (empty($this->getFrom())) {
            $this->from = [$this->getPrimaryTableName()];

The property from does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        if (empty($this->getSelect()) && !empty($this->getJoin())) {
            [, $alias] = $this->getTableNameAndAlias();

            $this->select(["$alias.*"]);
        }

        if ($this->primaryModel === null) {
            /** eager loading */
            $query = Query::create($this->modelClass::getConnection(), $this);

The method getConnection() does not exist on null.

        } else {
            // lazy loading of a relation
            $where = $this->getWhere();

            if ($this->via instanceof self) {
                /** via junction table */
                $viaModels = $this->via->findJunctionRows([$this->primaryModel]);

                $this->filterByModels($viaModels);
            } elseif (\is_array($this->via)) {
                /**
                 * via relation
                 *
                 * @var $viaQuery ActiveQuery
                 */
                [$viaName, $viaQuery, $viaCallableUsed] = $this->via;

                if ($viaQuery->getMultiple()) {
                    if ($viaCallableUsed) {
                        $viaModels = $viaQuery->all();
                    } elseif ($this->primaryModel->isRelationPopulated($viaName)) {
                        $viaModels = $this->primaryModel->$viaName;
                    } else {
                        $viaModels = $viaQuery->all();
                        $this->primaryModel->populateRelation($viaName, $viaModels);
                    }
                } else {
                    if ($viaCallableUsed) {
                        $model = $viaQuery->one();
                    } elseif ($this->primaryModel->isRelationPopulated($viaName)) {
                        $model = $this->primaryModel->$viaName;
                    } else {
                        $model = $viaQuery->one();
                        $this->primaryModel->populateRelation($viaName, $model);
                    }
                    $viaModels = $model === null ? [] : [$model];
                }
                $this->filterByModels($viaModels);
            } else {
                $this->filterByModels([$this->primaryModel]);
            }

            $query = Query::create($this->modelClass::getConnection(), $this);
            $this->where($where);
        }

        if (!empty($this->on)) {
            $query->andWhere($this->on);
        }

        return $query;
    }

    public function populate($rows): array
    {
        if (empty($rows)) {
            return [];
        }

        $models = $this->createModels($rows);

        if (!empty($this->join) && $this->getIndexBy() === null) {
            $models = $this->removeDuplicatedModels($models);
        }

        if (!empty($this->with)) {
            $this->findWith($this->with, $models);
        }

        if ($this->inverseOf !== null) {
            $this->addInverseRelations($models);
        }

        return parent::populate($models);
    }

    /**
     * Removes duplicated models by checking their primary key values.
     *
     * This method is mainly called when a join query is performed, which may cause duplicated rows being returned.
     *
     * @param array $models the models to be checked
     *
     * @throws Exception
     * @throws InvalidConfigException
     * @throws NotSupportedException
     *
     * @return array the distinctive models
     */
    private function removeDuplicatedModels($models): array
    {
        $hash = [];

        /** @var $class ActiveRecord */
        $class = $this->modelClass;

        $pks = $class::primaryKey();

        if (\count($pks) > 1) {
            /** composite primary key */
            foreach ($models as $i => $model) {
                $key = [];
                foreach ($pks as $pk) {
                    if (!isset($model[$pk])) {
                        /** do not continue if the primary key is not part of the result set */
                        break 2;
                    }
                    $key[] = $model[$pk];
                }

                $key = \serialize($key);

                if (isset($hash[$key])) {
                    unset($models[$i]);
                } else {
                    $hash[$key] = true;
                }
            }
        } elseif (empty($pks)) {
            throw new InvalidConfigException("Primary key of '{$class}' can not be empty.");
        } else {
            // single column primary key
            $pk = \reset($pks);

            foreach ($models as $i => $model) {
                if (!isset($model[$pk])) {
                    /** do not continue if the primary key is not part of the result set */
                    break;
                }

                $key = $model[$pk];

                if (isset($hash[$key])) {
                    unset($models[$i]);
                } elseif ($key !== null) {
                    $hash[$key] = true;
                }
            }
        }

        return \array_values($models);
    }

    /**
     * Executes query and returns a single row of result.
     *
     * @throws Exception
     * @throws InvalidArgumentException
     * @throws InvalidConfigException
     * @throws NotSupportedException
     *
     * @return ActiveRecord|array|null a single row of query result. Depending on the setting of {@see 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()
    {
        $row = parent::one();

        if ($row !== false) {

The condition $row !== false is always true.

            $models = $this->populate([$row]);

            return \reset($models) ?: null;
        }

        return null;
    }

    /**
     * Creates a DB command that can be used to execute this query.
     *
     * @return Command the created DB command instance.
     */
    public function createCommand(): Command
    {
        /** @var $modelClass ActiveRecord */
        $modelClass = $this->modelClass;

The assignment to $modelClass is dead and can be removed.

        if ($this->sql === null) {
            [$sql, $params] = $this->modelClass::getConnection()->getQueryBuilder()->build($this);
        } else {
            $sql = $this->sql;
            $params = $this->params;
        }

        $command = $this->modelClass::getConnection()->createCommand($sql, $params);

        $this->setCommandCache($command);

        return $command;
    }

    protected function queryScalar($selectExpression)
    {
        /* @var $modelClass ActiveRecord */
        $modelClass = $this->modelClass;

The assignment to $modelClass is dead and can be removed.

        if ($this->sql === null) {
            return parent::queryScalar($selectExpression);
        }

        $command = (new Query($this->modelClass::getConnection()))->select([$selectExpression])
            ->from(['c' => "({$this->sql})"])
            ->params($this->params)
            ->createCommand();

        $this->setCommandCache($command);

        return $command->queryScalar();
    }

    /**
     * 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 multiple 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 equivalent to calling {@see with()} using the specified relations.
     *
     * Note that because a JOIN query will be performed, you are responsible to disambiguate column names.
     *
     * This method differs from {@see 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 with()} in addition with the
     * specified relations.
     *
     * @param string|array $with the relations to be joined. This can either be a string, representing a relation name
     * or an array with the following semantics:
     *
     * - Each array element represents a single relation.
     * - You may specify the relation name as the array key and provide an anonymous functions that can be used to
     * modify the relation queries on-the-fly as the array value.
     * - If a relation query does not need modification, you may use the relation name as the array value.
     *
     * The relation name may optionally contain an alias for the relation table (e.g. `books b`).
     *
     * Sub-relations can also be specified, see {@see with()} for the syntax.
     *
     * In the following you find some examples:
     *
     * ```php
     * // find all orders that contain books, and eager loading "books"
     * Order::find()->joinWith('books', true, 'INNER JOIN')->all();
     * // find all orders, eager loading "books", and sort the orders and books by the book names.
     * Order::find()->joinWith([
     *     'books' => function (\Yiisoft\ActiveRecord\ActiveQuery $query) {
     *         $query->orderBy('item.name');
     *     }
     * ])->all();
     * // find all orders that contain books of the category 'Science fiction', using the alias "b" for the books table
     * Order::find()->joinWith(['books b'], true, 'INNER JOIN')->where(['b.category' => 'Science fiction'])->all();
     * ```
     *
     * @param bool|array $eagerLoading whether to eager load the relations specified in `$with`. When this is a boolean,
     * it applies to all relations specified in `$with`. Use an array to explicitly list which relations in `$with` need
     * to be eagerly loaded.  Note, that this does not mean, that the relations are populated from the query result. An
     * extra query will still be performed to bring in the related data. Defaults to `true`.
     * @param string|array $joinType the join type of the relations specified in `$with`.  When this is a string, it
     * applies to all relations specified in `$with`. Use an array in the format of `relationName => joinType` to
     * specify different join types for different relations.
     *
     * @return $this the query object itself.
     */
    public function joinWith($with, $eagerLoading = true, $joinType = 'LEFT JOIN'): self
    {
        $relations = [];

        foreach ((array) $with as $name => $callback) {
            if (\is_int($name)) {
                $name = $callback;
                $callback = null;
            }

            if (\preg_match('/^(.*?)(?:\s+AS\s+|\s+)(\w+)$/i', $name, $matches)) {
                /** relation is defined with an alias, adjust callback to apply alias */
                [, $relation, $alias] = $matches;

                $name = $relation;

                $callback = static function ($query) use ($callback, $alias) {
                    /** @var $query ActiveQuery */
                    $query->alias($alias);
                    if ($callback !== null) {
                        $callback($query);
                    }
                };
            }

            if ($callback === null) {
                $relations[] = $name;
            } else {
                $relations[$name] = $callback;
            }
        }

        $this->joinWith[] = [$relations, $eagerLoading, $joinType];

        return $this;
    }

    private function buildJoinWith()
    {
        $join = $this->join;

        $this->join = [];

The property join does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        /** @var $modelClass ActiveRecordInterface */
        $modelClass = $this->modelClass;

        $model = $modelClass::instance();

The method instance() does not exist on Yiisoft\ActiveRecord\ActiveRecordInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Yiisoft\ActiveRecord\ActiveRecordInterface.

        foreach ($this->joinWith as [$with, $eagerLoading, $joinType]) {
            $this->joinWithRelations($model, $with, $joinType);

            if (\is_array($eagerLoading)) {
                foreach ($with as $name => $callback) {
                    if (\is_int($name)) {
                        if (!\in_array($callback, $eagerLoading, true)) {
                            unset($with[$name]);
                        }
                    } elseif (!\in_array($name, $eagerLoading, true)) {
                        unset($with[$name]);
                    }
                }
            } elseif (!$eagerLoading) {
                $with = [];
            }

            $this->with($with);
        }

        /**
         * remove duplicated joins added by joinWithRelations that may be added e.g. when joining a relation and a via
         * relation at the same time.
         */
        $uniqueJoins = [];

        foreach ($this->join as $j) {
            $uniqueJoins[\serialize($j)] = $j;
        }

        $this->join = \array_values($uniqueJoins);

        if (!empty($join)) {
            /**
             * append explicit join to joinWith()
             *
             * {@see https://github.com/yiisoft/yii2/issues/2880}
             */
            $this->join = empty($this->join) ? $join : \array_merge($this->join, $join);
        }
    }

    /**
     * Inner joins with the specified relations.
     *
     * This is a shortcut method to {@see joinWith()} with the join type set as "INNER JOIN". Please refer to
     * {@see joinWith()} for detailed usage of this method.
     *
     * @param string|array $with the relations to be joined with.
     * @param bool|array $eagerLoading whether to eager load the relations. Note, that this does not mean, that the
     * relations are populated from the query result. An extra query will still be performed to bring in the related
     * data.
     *
     * @return $this the query object itself.
     *
     * {@see joinWith()}
     */
    public function innerJoinWith($with, $eagerLoading = true): self
    {
        return $this->joinWith($with, $eagerLoading, 'INNER JOIN');
    }

    /**
     * Modifies the current query by adding join fragments based on the given relations.
     *
     * @param ActiveRecord $model the primary model.
     * @param array $with the relations to be joined.
     * @param string|array $joinType the join type.
     *
     * @throws InvalidArgumentException
     * @throws \ReflectionException
     */
    private function joinWithRelations($model, $with, $joinType)
    {
        $relations = [];

        foreach ($with as $name => $callback) {
            if (\is_int($name)) {
                $name = $callback;
                $callback = null;
            }

            $primaryModel = $model;
            $parent = $this;
            $prefix = '';

            while (($pos = \strpos($name, '.')) !== false) {
                $childName = \substr($name, $pos + 1);
                $name = \substr($name, 0, $pos);
                $fullName = $prefix === '' ? $name : "$prefix.$name";

                if (!isset($relations[$fullName])) {
                    $relations[$fullName] = $relation = $primaryModel->getRelation($name);
                    $this->joinWithRelation($parent, $relation, $this->getJoinType($joinType, $fullName));
                } else {
                    $relation = $relations[$fullName];
                }

                /** @var $relationModelClass ActiveRecordInterface */
                $relationModelClass = $relation->modelClass;

Accessing modelClass on the interface Yiisoft\ActiveRecord\ActiveQueryInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                $primaryModel = new $relationModelClass();

                $parent = $relation;
                $prefix = $fullName;
                $name = $childName;
            }

            $fullName = $prefix === '' ? $name : "$prefix.$name";

            if (!isset($relations[$fullName])) {
                $relations[$fullName] = $relation = $primaryModel->getRelation($name);

                if ($callback !== null) {
                    $callback($relation);
                }

                if (!empty($relation->joinWith)) {

Accessing joinWith on the interface Yiisoft\ActiveRecord\ActiveQueryInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                    $relation->buildJoinWith();

The method buildJoinWith() does not exist on Yiisoft\ActiveRecord\ActiveQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Yiisoft\ActiveRecord\ActiveQueryInterface.

                }

                $this->joinWithRelation($parent, $relation, $this->getJoinType($joinType, $fullName));
            }
        }
    }

    /**
     * Returns the join type based on the given join type parameter and the relation name.
     *
     * @param string|array $joinType the given join type(s).
     * @param string $name relation name.
     *
     * @return string the real join type.
     */
    private function getJoinType($joinType, $name): string
    {
        if (\is_array($joinType) && isset($joinType[$name])) {
            return $joinType[$name];
        }

        return \is_string($joinType) ? $joinType : 'INNER JOIN';
    }

    /**
     * Returns the table name and the table alias for {@see modelClass}.
     *
     * @return array the table name and the table alias.
     */
    private function getTableNameAndAlias(): array
    {
        if (empty($this->from)) {
            $tableName = $this->getPrimaryTableName();
        } else {
            $tableName = '';

            foreach ($this->from as $alias => $tableName) {
                if (\is_string($alias)) {
                    return [$tableName, $alias];
                }
                break;
            }
        }

        if (\preg_match('/^(.*?)\s+({{\w+}}|\w+)$/', $tableName, $matches)) {
            $alias = $matches[2];
        } else {
            $alias = $tableName;
        }

        return [$tableName, $alias];
    }

    /**
     * Joins a parent query with a child query.
     *
     * The current query object will be modified accordingly.
     *
     * @param ActiveQuery $parent
     * @param ActiveQuery $child
     * @param string $joinType
     */
    private function joinWithRelation($parent, $child, $joinType)
    {
        $via = $child->via;
        $child->via = null;

        if ($via instanceof self) {
            /* via table */
            $this->joinWithRelation($parent, $via, $joinType);
            $this->joinWithRelation($via, $child, $joinType);

            return;
        }

        if (\is_array($via)) {
            /** via relation */
            $this->joinWithRelation($parent, $via[1], $joinType);
            $this->joinWithRelation($via[1], $child, $joinType);

            return;
        }

        [$parentTable, $parentAlias] = $parent->getTableNameAndAlias();
        [$childTable, $childAlias] = $child->getTableNameAndAlias();

        if (!empty($child->link)) {
            if (\strpos($parentAlias, '{{') === false) {
                $parentAlias = '{{' . $parentAlias . '}}';
            }

            if (\strpos($childAlias, '{{') === false) {
                $childAlias = '{{' . $childAlias . '}}';
            }

            $on = [];

            foreach ($child->link as $childColumn => $parentColumn) {
                $on[] = "$parentAlias.[[$parentColumn]] = $childAlias.[[$childColumn]]";
            }

            $on = \implode(' AND ', $on);

            if (!empty($child->on)) {
                $on = ['and', $on, $child->on];
            }
        } else {
            $on = $child->on;
        }

        $this->join($joinType, empty($child->getFrom()) ? $childTable : $child->getFrom(), $on);

        if (!empty($child->getWhere())) {
            $this->andWhere($child->getWhere());
        }

        if (!empty($child->getHaving())) {
            $this->andHaving($child->getHaving());
        }

        if (!empty($child->getOrderBy())) {
            $this->addOrderBy($child->getOrderBy());
        }

        if (!empty($child->getGroupBy())) {
            $this->addGroupBy($child->getGroupBy());
        }

        if (!empty($child->getParams())) {
            $this->addParams($child->getParams());
        }

        if (!empty($child->getJoin())) {
            foreach ($child->getJoin() as $join) {
                $this->join[] = $join;

The property join does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            }
        }

        if (!empty($child->getUnion())) {
            foreach ($child->getUnion() as $union) {
                $this->union[] = $union;

The property union does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            }
        }
    }

    /**
     * Sets the ON condition for a relational query.
     *
     * The condition will be used in the ON part when {@see ActiveQuery::joinWith()} is called.
     *
     * Otherwise, the condition will be used in the WHERE part of a query.
     *
     * Use this method to specify additional conditions when declaring a relation in the {@see ActiveRecord} class:
     *
     * ```php
     * public function getActiveUsers()
     * {
     *     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. This 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.
     *
     * @param string|array $condition the ON condition. Please refer to {@see Query::where()} on how to specify this
     * parameter.
     * @param array $params the parameters (name => value) to be bound to the query.
     *
     * @return $this the query object itself
     */
    public function onCondition($condition, $params = []): self
    {
        $this->on = $condition;
        $this->addParams($params);

        return $this;
    }

    /**
     * Adds an additional ON 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 ON condition. Please refer to {@see where()} on how to specify this
     * parameter.
     * @param array $params the parameters (name => value) to be bound to the query.
     *
     * @return $this the query object itself.
     *
     * {@see onCondition()}
     * {@see orOnCondition()}
     */
    public function andOnCondition($condition, $params = []): self
    {
        if ($this->on === null) {
            $this->on = $condition;
        } else {
            $this->on = ['and', $this->on, $condition];
        }

        $this->addParams($params);

        return $this;
    }

    /**
     * Adds an additional ON 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 ON condition. Please refer to {@see where()} on how to specify this
     * parameter.
     * @param array $params the parameters (name => value) to be bound to the query.
     *
     * @return $this the query object itself.
     *
     * {@see onCondition()}
     * {@see andOnCondition()}
     */
    public function orOnCondition($condition, $params = []): self
    {
        if ($this->on === null) {
            $this->on = $condition;
        } else {
            $this->on = ['or', $this->on, $condition];
        }

        $this->addParams($params);

        return $this;
    }

    /**
     * Specifies the junction table for a relational query.
     *
     * Use this method to specify a junction table when declaring a relation in the {@see ActiveRecord} class:
     *
     * ```php
     * public function getItems()
     * {
     *     return $this->hasMany(Item::class, ['id' => 'item_id'])
     *                 ->viaTable('order_item', ['order_id' => 'id']);
     * }
     * ```
     *
     * @param string $tableName the name of the junction table.
     * @param array $link the link between the junction table and the table associated with {@see primaryModel}.
     * The keys of the array represent the columns in the junction table, and the values represent the columns
     * in the {@see primaryModel} table.
     * @param callable $callable 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 $this the query object itself.
     *
     * {@see via()}
     */
    public function viaTable($tableName, $link, callable $callable = null): self
    {
        $modelClass = $this->primaryModel ? \get_class($this->primaryModel) : $this->modelClass;

        $relation = (new self($modelClass))->from([$tableName])->link($link)->multiple(true)->asArray(true);

        $this->via = $relation;

        if ($callable !== null) {
            $callable($relation);
        }

        return $this;
    }

    /**
     * Define an alias for the table defined in {@see modelClass}.
     *
     * This method will adjust {@see from} so that an already defined alias will be overwritten. If none was defined,
     * {@see from} will be populated with the given alias.
     *
     * @param string $alias the table alias.
     *
     * @return $this the query object itself.
     */
    public function alias($alias): self
    {
        if (empty($this->from) || \count($this->from) < 2) {
            [$tableName] = $this->getTableNameAndAlias();
            $this->from = [$alias => $tableName];

The property from does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        } else {
            $tableName = $this->getPrimaryTableName();

            foreach ($this->from as $key => $table) {
                if ($table === $tableName) {
                    unset($this->from[$key]);
                    $this->from[$alias] = $tableName;
                }
            }
        }

        return $this;
    }

    public function getTablesUsedInFrom(): array
    {
        if (empty($this->from)) {
            return $this->cleanUpTableNames([$this->getPrimaryTableName()]);
        }

        return parent::getTablesUsedInFrom();
    }

    protected function getPrimaryTableName(): string
    {
        /** @var $modelClass ActiveRecord */
        $modelClass = $this->modelClass;

        return $modelClass::tableName();
    }

    /**
     * @return string|array the join condition to be used when this query is used in a relational context.
     *
     * The condition will be used in the ON part when {@see ActiveQuery::joinWith()} is called. Otherwise, the condition
     * will be used in the WHERE part of a query.
     *
     * Please refer to {@see Query::where()} on how to specify this parameter.
     *
     * {@see onCondition()}
     */
    public function getOn()
    {
        return $this->on;
    }

    /**
     * @return array $value a list of relations that this query should be joined with
     */
    public function getJoinWith(): array
    {
        return $this->joinWith;
    }

    /**
     * @return string|null the SQL statement to be executed for retrieving AR records.
     *
     * This is set by {@see ActiveRecord::findBySql()}.
     */
    public function getSql(): ?string
    {
        return $this->sql;
    }

    public function getModelClass(): ?string
    {
        return $this->modelClass;
    }

    public function on($value): self
    {
        $this->on = $value;

        return $this;
    }

    public function sql(?string $value): self
    {
        $this->sql = $value;

        return $this;
    }
}