Class yii\db\Query

                public function __toString()
{
    return serialize($this);
}

            

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

            

                public function addParams($params)
{
    if (!empty($params)) {
        if (empty($this->params)) {
            $this->params = $params;
        } else {
            foreach ($params as $name => $value) {
                if (is_int($name)) {
                    $this->params[] = $value;
                } else {
                    $this->params[$name] = $value;
                }
            }
        }
    }
    return $this;
}

            

                public function addSelect($columns)
{
    if ($this->select === null) {
        return $this->select($columns);
    }
    if (!is_array($this->select)) {
        $this->select = $this->normalizeSelect($this->select);
    }
    $this->select = array_merge($this->select, $this->normalizeSelect($columns));
    return $this;
}

            

                public function all($db = null)
{
    if ($this->emulateExecution) {
        return [];
    }
    $rows = $this->createCommand($db)->queryAll();
    return $this->populate($rows);
}

            

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

            

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

            

                public function andHaving($condition, $params = [])
{
    if ($this->having === null) {
        $this->having = $condition;
    } else {
        $this->having = ['and', $this->having, $condition];
    }
    $this->addParams($params);
    return $this;
}

            

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

            

                public function average($q, $db = null)
{
    if ($this->emulateExecution) {
        return 0;
    }
    return $this->queryScalar("AVG($q)", $db);
}

            

                public function batch($batchSize = 100, $db = null)
{
    return Yii::createObject([
        'class' => BatchQueryResult::className(),
        'query' => $this,
        'batchSize' => $batchSize,
        'db' => $db,
        'each' => false,
    ]);
}

            

                public function cache($duration = true, $dependency = null)
{
    $this->queryCacheDuration = $duration;
    $this->queryCacheDependency = $dependency;
    return $this;
}

            

                protected function cleanUpTableNames($tableNames)
{
    $cleanedUpTableNames = [];
    foreach ($tableNames as $alias => $tableName) {
        if (is_string($tableName) && !is_string($alias)) {
            $pattern = <<<PATTERN
'"`\[]|{{)
'"`\]]|}})
?\)
\s+
(?:as)?
\s*
?:['"`\[]|{{)
.*?
(?:['"`\]]|}})
|
.*?

ERN;
            if (preg_match($pattern, $tableName, $matches)) {
                if (isset($matches[2])) {
                    list(, $tableName, $alias) = $matches;
                } else {
                    $tableName = $alias = $matches[1];
                }
            }
        }
        if ($tableName instanceof Expression) {
            if (!is_string($alias)) {
                throw new InvalidArgumentException('To use Expression in from() method, pass it in array format with alias.');
            }
            $cleanedUpTableNames[$this->ensureNameQuoted($alias)] = $tableName;
        } elseif ($tableName instanceof self) {
            $cleanedUpTableNames[$this->ensureNameQuoted($alias)] = $tableName;
        } else {
            $cleanedUpTableNames[$this->ensureNameQuoted($alias)] = $this->ensureNameQuoted($tableName);
        }
    }
    return $cleanedUpTableNames;
}

            

                public function column($db = null)
{
    if ($this->emulateExecution) {
        return [];
    }
    if ($this->indexBy === null) {
        return $this->createCommand($db)->queryColumn();
    }
    if (is_string($this->indexBy) && is_array($this->select) && count($this->select) === 1) {
        if (strpos($this->indexBy, '.') === false && count($tables = $this->getTablesUsedInFrom()) > 0) {
            $this->select[] = key($tables) . '.' . $this->indexBy;
        } else {
            $this->select[] = $this->indexBy;
        }
    }
    $rows = $this->createCommand($db)->queryAll();
    $results = [];
    $column = null;
    if (is_string($this->indexBy)) {
        if (($dotPos = strpos($this->indexBy, '.')) === false) {
            $column = $this->indexBy;
        } else {
            $column = substr($this->indexBy, $dotPos + 1);
        }
    }
    foreach ($rows as $row) {
        $value = reset($row);
        if ($this->indexBy instanceof \Closure) {
            $results[call_user_func($this->indexBy, $row)] = $value;
        } else {
            $results[$row[$column]] = $value;
        }
    }
    return $results;
}

            

                public function count($q = '*', $db = null)
{
    if ($this->emulateExecution) {
        return 0;
    }
    return $this->queryScalar("COUNT($q)", $db);
}

            

                public static function create($from)
{
    return new self([
        'where' => $from->where,
        'limit' => $from->limit,
        'offset' => $from->offset,
        'orderBy' => $from->orderBy,
        'indexBy' => $from->indexBy,
        'select' => $from->select,
        'selectOption' => $from->selectOption,
        'distinct' => $from->distinct,
        'from' => $from->from,
        'groupBy' => $from->groupBy,
        'join' => $from->join,
        'having' => $from->having,
        'union' => $from->union,
        'params' => $from->params,
        'withQueries' => $from->withQueries,
    ]);
}

            

                public function createCommand($db = null)
{
    if ($db === null) {
        $db = Yii::$app->getDb();
    }
    list($sql, $params) = $db->getQueryBuilder()->build($this);
    $command = $db->createCommand($sql, $params);
    $this->setCommandCache($command);
    return $command;
}

            

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

            

                public function each($batchSize = 100, $db = null)
{
    return Yii::createObject([
        'class' => BatchQueryResult::className(),
        'query' => $this,
        'batchSize' => $batchSize,
        'db' => $db,
        'each' => true,
    ]);
}

            

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

            

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

            

                public function from($tables)
{
    if ($tables instanceof ExpressionInterface) {
        $tables = [$tables];
    }
    if (is_string($tables)) {
        $tables = preg_split('/\s*,\s*/', trim($tables), -1, PREG_SPLIT_NO_EMPTY);
    }
    $this->from = $tables;
    return $this;
}

            

                public function getTablesUsedInFrom()
{
    if (empty($this->from)) {
        return [];
    }
    if (is_array($this->from)) {
        $tableNames = $this->from;
    } elseif (is_string($this->from)) {
        $tableNames = preg_split('/\s*,\s*/', trim($this->from), -1, PREG_SPLIT_NO_EMPTY);
    } elseif ($this->from instanceof Expression) {
        $tableNames = [$this->from];
    } else {
        throw new InvalidConfigException(gettype($this->from) . ' in $from is not supported.');
    }
    return $this->cleanUpTableNames($tableNames);
}

            

                protected function getUnaliasedColumnsFromSelect()
{
    $result = [];
    if (is_array($this->select)) {
        foreach ($this->select as $name => $value) {
            if (is_int($name)) {
                $result[] = $value;
            }
        }
    }
    return array_unique($result);
}

            

                protected function getUniqueColumns($columns)
{
    $unaliasedColumns = $this->getUnaliasedColumnsFromSelect();
    $result = [];
    foreach ($columns as $columnAlias => $columnDefinition) {
        if (!$columnDefinition instanceof Query) {
            if (is_string($columnAlias)) {
                $existsInSelect = isset($this->select[$columnAlias]) && $this->select[$columnAlias] === $columnDefinition;
                if ($existsInSelect) {
                    continue;
                }
            } elseif (is_int($columnAlias)) {
                $existsInSelect = in_array($columnDefinition, $unaliasedColumns, true);
                $existsInResultSet = in_array($columnDefinition, $result, true);
                if ($existsInSelect || $existsInResultSet) {
                    continue;
                }
            }
        }
        $result[$columnAlias] = $columnDefinition;
    }
    return $result;
}

            

                public function groupBy($columns)
{
    if ($columns instanceof ExpressionInterface) {
        $columns = [$columns];
    } elseif (!is_array($columns) && !is_null($columns)) {
        $columns = preg_split('/\s*,\s*/', trim($columns), -1, PREG_SPLIT_NO_EMPTY);
    }
    $this->groupBy = $columns;
    return $this;
}

            

                public function having($condition, $params = [])
{
    $this->having = $condition;
    $this->addParams($params);
    return $this;
}

            

                public function innerJoin($table, $on = '', $params = [])
{
    $this->join[] = ['INNER JOIN', $table, $on];
    return $this->addParams($params);
}

            

                public function join($type, $table, $on = '', $params = [])
{
    $this->join[] = [$type, $table, $on];
    return $this->addParams($params);
}

            

                public function leftJoin($table, $on = '', $params = [])
{
    $this->join[] = ['LEFT JOIN', $table, $on];
    return $this->addParams($params);
}

            

                public function max($q, $db = null)
{
    return $this->queryScalar("MAX($q)", $db);
}

            

                public function min($q, $db = null)
{
    return $this->queryScalar("MIN($q)", $db);
}

            

                public function noCache()
{
    $this->queryCacheDuration = -1;
    return $this;
}

            

                protected function normalizeSelect($columns)
{
    if ($columns instanceof ExpressionInterface) {
        $columns = [$columns];
    } elseif (!is_array($columns)) {
        $columns = preg_split('/\s*,\s*/', trim((string)$columns), -1, PREG_SPLIT_NO_EMPTY);
    }
    $select = [];
    foreach ($columns as $columnAlias => $columnDefinition) {
        if (is_string($columnAlias)) {
            // Already in the normalized format, good for them
            $select[$columnAlias] = $columnDefinition;
            continue;
        }
        if (is_string($columnDefinition)) {
            if (
                preg_match('/^(.*?)(?i:\s+as\s+|\s+)([\w\-_\.]+)$/', $columnDefinition, $matches) &&
                !preg_match('/^\d+$/', $matches[2]) &&
                strpos($matches[2], '.') === false
            ) {
                // Using "columnName as alias" or "columnName alias" syntax
                $select[$matches[2]] = $matches[1];
                continue;
            }
            if (strpos($columnDefinition, '(') === false) {
                // Normal column name, just alias it to itself to ensure it's not selected twice
                $select[$columnDefinition] = $columnDefinition;
                continue;
            }
        }
        // Either a string calling a function, DB expression, or sub-query
        $select[] = $columnDefinition;
    }
    return $select;
}

            

                public function one($db = null)
{
    if ($this->emulateExecution) {
        return false;
    }
    return $this->createCommand($db)->queryOne();
}

            

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

            

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

            

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

            

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

            

                public function populate($rows)
{
    if ($this->indexBy === null) {
        return $rows;
    }
    $result = [];
    foreach ($rows as $row) {
        $result[ArrayHelper::getValue($row, $this->indexBy)] = $row;
    }
    return $result;
}

            

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

            

                protected function queryScalar($selectExpression, $db)
{
    if ($this->emulateExecution) {
        return null;
    }
    if (
        !$this->distinct
        && empty($this->groupBy)
        && empty($this->having)
        && empty($this->union)
    ) {
        $select = $this->select;
        $order = $this->orderBy;
        $limit = $this->limit;
        $offset = $this->offset;
        $this->select = [$selectExpression];
        $this->orderBy = null;
        $this->limit = null;
        $this->offset = null;
        $e = null;
        try {
            $command = $this->createCommand($db);
        } catch (\Exception $e) {
            // throw it later (for PHP < 7.0)
        } catch (\Throwable $e) {
            // throw it later
        }
        $this->select = $select;
        $this->orderBy = $order;
        $this->limit = $limit;
        $this->offset = $offset;
        if ($e !== null) {
            throw $e;
        }
        return $command->queryScalar();
    }
    $command = (new self())
        ->select([$selectExpression])
        ->from(['c' => $this])
        ->createCommand($db);
    $this->setCommandCache($command);
    return $command->queryScalar();
}

            

                public function rightJoin($table, $on = '', $params = [])
{
    $this->join[] = ['RIGHT JOIN', $table, $on];
    return $this->addParams($params);
}

            

                public function scalar($db = null)
{
    if ($this->emulateExecution) {
        return null;
    }
    return $this->createCommand($db)->queryScalar();
}

            

                public function select($columns, $option = null)
{
    $this->select = $this->normalizeSelect($columns);
    $this->selectOption = $option;
    return $this;
}

            

                protected function setCommandCache($command)
{
    if ($this->queryCacheDuration !== null || $this->queryCacheDependency !== null) {
        $duration = $this->queryCacheDuration === true ? null : $this->queryCacheDuration;
        $command->cache($duration, $this->queryCacheDependency);
    }
    return $command;
}

            

                public function sum($q, $db = null)
{
    if ($this->emulateExecution) {
        return 0;
    }
    return $this->queryScalar("SUM($q)", $db);
}

            

                public function union($sql, $all = false)
{
    $this->union[] = ['query' => $sql, 'all' => $all];
    return $this;
}

            

                public function where($condition, $params = [])
{
    $this->where = $condition;
    $this->addParams($params);
    return $this;
}

            

                public function withQuery($query, $alias, $recursive = false)
{
    $this->withQueries[] = ['query' => $query, 'alias' => $alias, 'recursive' => $recursive];
    return $this;
}