Class Yiisoft\Db\Query\Query

                public function __construct(protected ConnectionInterface $db) {}

            

                public function addFor(string|array|null $value): static
{
    if ($value === null) {
        return $this;
    }
    if (is_array($value)) {
        $this->for = [...$this->for, ...$value];
        return $this;
    }
    $this->for[] = $value;
    return $this;
}

            

                public function addGroupBy(array|string|ExpressionInterface $columns): static
{
    if ($columns instanceof ExpressionInterface) {
        $columns = [$columns];
    } elseif (!is_array($columns)) {
        /** @var string[] */
        $columns = preg_split('/\s*,\s*/', trim($columns), -1, PREG_SPLIT_NO_EMPTY);
    }
    if ($this->groupBy === []) {
        $this->groupBy = $columns;
    } else {
        $this->groupBy = array_merge($this->groupBy, $columns);
    }
    return $this;
}

            

                public function addOrderBy(array|string|ExpressionInterface $columns): static
{
    $columns = $this->normalizeOrderBy($columns);
    if ($this->orderBy === []) {
        $this->orderBy = $columns;
    } else {
        $this->orderBy = array_merge($this->orderBy, $columns);
    }
    return $this;
}

            

                public function addParams(array $params): static
{
    if (empty($params)) {
        return $this;
    }
    if (empty($this->params)) {
        $this->params = $params;
        return $this;
    }
    if (is_int(key($params))) {
        array_push($this->params, ...$params);
        return $this;
    }
    $this->params = [...$this->params, ...$params];
    return $this;
}

            

                public function addSelect(array|bool|float|int|string|ExpressionInterface $columns): static
{
    if ($this->select === []) {
        return $this->select($columns);
    }
    $this->select = array_merge($this->select, $this->normalizeSelect($columns));
    return $this;
}

            

                public function addWithQuery(
    QueryInterface|string $query,
    ExpressionInterface|string $alias,
    bool $recursive = false,
): static {
    $this->withQueries[] = new WithQuery($query, $alias, $recursive);
    return $this;
}

            

                public function all(): array
{
    if ($this->emulateExecution === true) {
        return [];
    }
    return $this->index($this->createCommand()->queryAll());
}

            

                public function andFilterCompare(string $column, ?string $value, string $defaultOperator = '='): static
{
    $operator = $defaultOperator;
    if (preg_match('/^(<>|>=|>|<=|<|=)/', (string) $value, $matches)) {
        $operator = $matches[1];
        $value = substr((string) $value, strlen($operator));
    }
    return $this->andFilterWhere([$operator, $column, $value]);
}

            

                public function andFilterHaving(array $condition): static
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->andHaving($condition);
    }
    return $this;
}

            

                public function andFilterWhere(array $condition): static
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->andWhere($condition);
    }
    return $this;
}

            

                public function andHaving(array|string|ExpressionInterface $condition, array $params = []): static
{
    if ($this->having === null) {
        $this->having = $condition;
    } elseif (
        is_array($this->having)
        && isset($this->having[0])
        && strcasecmp((string) $this->having[0], 'and') === 0
    ) {
        $this->having[] = $condition;
    } else {
        $this->having = ['and', $this->having, $condition];
    }
    $this->addParams($params);
    return $this;
}

            

                public function andWhere($condition, array $params = []): static
{
    if ($this->where === null) {
        $this->where = $condition;
    } elseif (
        is_array($this->where)
        && isset($this->where[0])
        && strcasecmp((string) $this->where[0], 'and') === 0
    ) {
        $this->where[] = $condition;
    } else {
        $this->where = ['and', $this->where, $condition];
    }
    $this->addParams($params);
    return $this;
}

            

                public function average(string $sql): int|float|string|null
{
    return match ($this->emulateExecution) {
        true => null,
        false => is_numeric($avg = $this->queryScalar("AVG($sql)")) ? $avg : null,
    };
}

            

                public function batch(int $batchSize = 100): BatchQueryResultInterface
{
    return $this->db
        ->createBatchQueryResult($this)
        ->batchSize($batchSize);
}

            

                public function column(): array
{
    if ($this->emulateExecution) {
        return [];
    }
    if ($this->indexBy === null) {
        return $this->createCommand()->queryColumn();
    }
    if (is_string($this->indexBy)) {
        if (count($this->select) === 1) {
            if (!str_contains($this->indexBy, '.') && count($tables = $this->getTablesUsedInFrom()) > 0) {
                $this->select[] = key($tables) . '.' . $this->indexBy;
            } else {
                $this->select[] = $this->indexBy;
            }
        }
        $rows = $this->createCommand()->queryAll();
        if (empty($rows)) {
            return [];
        }
        if (($dotPos = strpos($this->indexBy, '.')) === false) {
            $column = $this->indexBy;
        } else {
            $column = substr($this->indexBy, $dotPos + 1);
        }
        return array_column($rows, key(current($rows)), $column);
    }
    $rows = $this->createCommand()->queryAll();
    if (empty($rows)) {
        return [];
    }
    return array_combine(array_map($this->indexBy, $rows), array_column($rows, key(current($rows))));
}

            

                public function count(string $sql = '*'): int|string
{
    /** @var int|string|null $count */
    $count = $this->queryScalar("COUNT($sql)");
    if ($count === null) {
        return 0;
    }
    /** @psalm-var non-negative-int|string */
    return $count <= PHP_INT_MAX ? (int) $count : $count;
}

            

                public function createCommand(): CommandInterface
{
    [$sql, $params] = $this->db->getQueryBuilder()->build($this);
    return $this->db->createCommand($sql, $params)->withPhpTypecasting($this->typecasting);
}

            

                public function distinct(bool $value = true): static
{
    $this->distinct = $value;
    return $this;
}

            

                public function each(): DataReaderInterface
{
    return $this->createCommand()
        ->query()
        ->indexBy($this->indexBy)
        ->resultCallback($this->resultCallback !== null ? $this->callResultCallbackOnOne(...) : null);
}

            

                public function emulateExecution(bool $value = true): static
{
    $this->emulateExecution = $value;
    return $this;
}

            

                public function exists(): bool
{
    if ($this->emulateExecution) {
        return false;
    }
    $command = $this->createCommand();
    $params = $command->getParams();
    $command->setSql($this->db->getQueryBuilder()->selectExists($command->getSql()));
    $command->bindValues($params);
    return (bool) $command->queryScalar();
}

            

                public function filterHaving(array $condition): static
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->having($condition);
    }
    return $this;
}

            

                public function filterWhere(array $condition): static
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->where($condition);
    }
    return $this;
}

            

                public function for(string|array|null $value): static
{
    if ($this->for !== []) {
        throw new LogicException('The `FOR` part was set earlier. Use the `setFor()` or `addFor()` method.');
    }
    return $this->setFor($value);
}

            

                public function from(array|ExpressionInterface|string $tables): static
{
    $this->from = DbArrayHelper::normalizeExpressions($tables);
    return $this;
}

            

                public function getDistinct(): bool
{
    return $this->distinct;
}

            

                public function getFor(): array
{
    return $this->for;
}

            

                public function getFrom(): array
{
    return $this->from;
}

            

                public function getGroupBy(): array
{
    return $this->groupBy;
}

            

                public function getHaving(): string|array|ExpressionInterface|null
{
    return $this->having;
}

            

                public function getIndexBy(): Closure|string|null
{
    return $this->indexBy;
}

            

                public function getJoins(): array
{
    return $this->joins;
}

            

                public function getLimit(): ExpressionInterface|int|null
{
    return $this->limit;
}

            

                public function getOffset(): ExpressionInterface|int|null
{
    return $this->offset;
}

            

                public function getOrderBy(): array
{
    return $this->orderBy;
}

            

                public function getParams(): array
{
    return $this->params;
}

            

                public function getResultCallback(): ?Closure
{
    return $this->resultCallback;
}

            

                public function getSelect(): array
{
    return $this->select;
}

            

                public function getSelectOption(): ?string
{
    return $this->selectOption;
}

            

                public function getTablesUsedInFrom(): array
{
    return $this->db->getQuoter()->cleanUpTableNames($this->from);
}

            

                public function getUnions(): array
{
    return $this->union;
}

            

                public function getWhere(): array|string|ExpressionInterface|null
{
    return $this->where;
}

            

                public function getWithQueries(): array
{
    return $this->withQueries;
}

            

                public function groupBy(array|string|ExpressionInterface $columns): static
{
    $this->groupBy = DbArrayHelper::normalizeExpressions($columns);
    return $this;
}

            

                public function having(array|ExpressionInterface|string|null $condition, array $params = []): static
{
    if ($this->having === null) {
        $this->having = $condition;
    } else {
        throw new LogicException('The `having` condition was set earlier. Use the `setHaving()`, `andHaving()` or `orHaving()` method.');
    }
    $this->addParams($params);
    return $this;
}

            

                protected function index(array $rows): array
{
    return DbArrayHelper::index($rows, $this->indexBy, $this->resultCallback);
}

            

                public function indexBy(Closure|string|null $column): static
{
    $this->indexBy = $column;
    return $this;
}

            

                public function innerJoin(
    array|ExpressionInterface|string $table,
    array|ExpressionInterface|string $on = '',
    array $params = [],
): static {
    $this->joins[] = ['INNER JOIN', $table, $on];
    return $this->addParams($params);
}

            

                public function join(
    string $type,
    array|ExpressionInterface|string $table,
    array|ExpressionInterface|string $on = '',
    array $params = [],
): static {
    $this->joins[] = [$type, $table, $on];
    return $this->addParams($params);
}

            

                public function leftJoin(
    array|ExpressionInterface|string $table,
    array|ExpressionInterface|string $on = '',
    array $params = [],
): static {
    $this->joins[] = ['LEFT JOIN', $table, $on];
    return $this->addParams($params);
}

            

                public function limit(ExpressionInterface|int|null $limit): static
{
    $this->limit = $limit;
    return $this;
}

            

                public function max(string $sql): int|float|string|null
{
    $max = $this->queryScalar("MAX($sql)");
    return is_numeric($max) ? $max : null;
}

            

                public function min(string $sql): int|float|string|null
{
    $min = $this->queryScalar("MIN($sql)");
    return is_numeric($min) ? $min : null;
}

            

                public function offset(ExpressionInterface|int|null $offset): static
{
    $this->offset = $offset;
    return $this;
}

            

                public function one(): array|object|null
{
    if ($this->emulateExecution) {
        return null;
    }
    $row = $this->createCommand()->queryOne();
    if ($this->resultCallback === null || $row === null) {
        return $row;
    }
    return $this->callResultCallbackOnOne($row);
}

            

                public function orFilterHaving(array $condition): static
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->orHaving($condition);
    }
    return $this;
}

            

                public function orFilterWhere(array $condition): static
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->orWhere($condition);
    }
    return $this;
}

            

                public function orHaving(array|string|ExpressionInterface $condition, array $params = []): static
{
    if ($this->having === null) {
        $this->having = $condition;
    } else {
        $this->having = ['or', $this->having, $condition];
    }
    $this->addParams($params);
    return $this;
}

            

                public function orWhere(array|string|ExpressionInterface $condition, array $params = []): static
{
    if ($this->where === null) {
        $this->where = $condition;
    } else {
        $this->where = ['or', $this->where, $condition];
    }
    $this->addParams($params);
    return $this;
}

            

                public function orderBy(array|string|ExpressionInterface $columns): static
{
    $this->orderBy = $this->normalizeOrderBy($columns);
    return $this;
}

            

                public function params(array $params): static
{
    $this->params = $params;
    return $this;
}

            

                public function prepare(QueryBuilderInterface $builder): QueryInterface
{
    return $this;
}

            

                protected function queryScalar(string|ExpressionInterface $selectExpression): bool|int|string|float|null
{
    if ($this->emulateExecution) {
        return null;
    }
    if (
        !$this->distinct
        && empty($this->groupBy)
        && empty($this->having)
        && empty($this->union)
    ) {
        $query = clone $this;
        $query->select = [$selectExpression];
        $query->orderBy = [];
        $query->limit = null;
        $query->offset = null;
        return $query->createCommand()->queryScalar();
    }
    $query = (new self($this->db))->select($selectExpression)->from(['c' => $this]);
    [$sql, $params] = $this->db->getQueryBuilder()->build($query);
    $command = $this->db->createCommand($sql, $params);
    return $command->queryScalar();
}

            

                public function resultCallback(?Closure $resultCallback): static
{
    $this->resultCallback = $resultCallback;
    return $this;
}

            

                public function rightJoin(
    array|ExpressionInterface|string $table,
    array|ExpressionInterface|string $on = '',
    array $params = [],
): static {
    $this->joins[] = ['RIGHT JOIN', $table, $on];
    return $this->addParams($params);
}

            

                public function scalar(): bool|int|string|float|null
{
    return match ($this->emulateExecution) {
        true => null,
        false => $this->createCommand()->queryScalar(),
    };
}

            

                public function select(array|bool|float|int|string|ExpressionInterface $columns, ?string $option = null): static
{
    $this->select = $this->normalizeSelect($columns);
    $this->selectOption = $option;
    return $this;
}

            

                public function selectOption(?string $value): static
{
    $this->selectOption = $value;
    return $this;
}

            

                public function setFor(array|string|null $value): static
{
    if ($value === null) {
        $this->for = [];
        return $this;
    }
    $this->for = (array) $value;
    return $this;
}

            

                public function setHaving(array|ExpressionInterface|string|null $condition, array $params = []): static
{
    $this->having = $condition;
    $this->addParams($params);
    return $this;
}

            

                public function setJoins(array $value): static
{
    $this->joins = $value;
    return $this;
}

            

                public function setUnions(array $value): static
{
    $this->union = $value;
    return $this;
}

            

                public function setWhere(array|string|ExpressionInterface|null $condition, array $params = []): static
{
    $this->where = $condition;
    $this->addParams($params);
    return $this;
}

            

                public function shouldEmulateExecution(): bool
{
    return $this->emulateExecution;
}

            

                public function sum(string $sql): int|float|string|null
{
    return match ($this->emulateExecution) {
        true => null,
        false => is_numeric($sum = $this->queryScalar("SUM($sql)")) ? $sum : null,
    };
}

            

                public function union(QueryInterface|string $sql, bool $all = false): static
{
    $this->union[] = ['query' => $sql, 'all' => $all];
    return $this;
}

            

                public function where(array|string|ExpressionInterface|null $condition, array $params = []): static
{
    if ($this->where !== null) {
        throw new LogicException(
            'The `where` condition was set earlier. Use the `setWhere()`, `andWhere()` or `orWhere()` method.',
        );
    }
    $this->where = $condition;
    $this->addParams($params);
    return $this;
}

            

                public function withQueries(WithQuery ...$queries): static
{
    $this->withQueries = $queries;
    return $this;
}

            

                public function withQuery(
    QueryInterface|string $query,
    ExpressionInterface|string $alias,
    bool $recursive = false,
): static {
    $this->withQueries = [new WithQuery($query, $alias, $recursive)];
    return $this;
}

            

                public function withTypecasting(bool $typecasting = true): static
{
    $new = clone $this;
    $new->typecasting = $typecasting;
    return $new;
}