Class yii\redis\ActiveQuery

                public function __construct($modelClass, $config = [])
{
    $this->modelClass = $modelClass;
    parent::__construct($config);
}

            

                public function all($db = null)
{
    if ($this->emulateExecution) {
        return [];
    }
    // TODO add support for orderBy
    $data = $this->executeScript($db, 'All');
    if (empty($data)) {
        return [];
    }
    $rows = [];
    foreach ($data as $dataRow) {
        $row = [];
        $c = count($dataRow);
        for ($i = 0; $i < $c;) {
            $row[$dataRow[$i++]] = $dataRow[$i++];
        }
        $rows[] = $row;
    }
    if (empty($rows)) {
        return [];
    }
    $models = $this->createModels($rows);
    if (!empty($this->with)) {
        $this->findWith($this->with, $models);
    }
    if ($this->indexBy !== null) {
        $indexedModels = [];
        if (is_string($this->indexBy)) {
            foreach ($models as $model) {
                $key = $model[$this->indexBy];
                $indexedModels[$key] = $model;
            }
        } else {
            foreach ($models as $model) {
                $key = call_user_func($this->indexBy, $model);
                $indexedModels[$key] = $model;
            }
        }
        $models = $indexedModels;
    }
    if (!$this->asArray) {
        foreach ($models as $model) {
            $model->afterFind();
        }
    }
    return $models;
}

            

                public function average($column, $db = null)
{
    if ($this->emulateExecution) {
        return 0;
    }
    return $this->executeScript($db, 'Average', $column);
}

            

                public function column($column, $db = null)
{
    if ($this->emulateExecution) {
        return [];
    }
    // TODO add support for orderBy
    return $this->executeScript($db, 'Column', $column);
}

            

                public function count($q = '*', $db = null)
{
    if ($this->emulateExecution) {
        return 0;
    }
    if ($this->where === null) {
        /* @var $modelClass ActiveRecord */
        $modelClass = $this->modelClass;
        if ($db === null) {
            $db = $modelClass::getDb();
        }
        return $db->executeCommand('LLEN', [$modelClass::keyPrefix()]);
    }
    return $this->executeScript($db, 'Count');
}

            

                protected function executeScript($db, $type, $columnName = null)
{
    if ($this->primaryModel !== null) {
        // lazy loading
        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 */
            list($viaName, $viaQuery) = $this->via;
            if ($viaQuery->multiple) {
                $viaModels = $viaQuery->all();
                $this->primaryModel->populateRelation($viaName, $viaModels);
            } else {
                $model = $viaQuery->one();
                $this->primaryModel->populateRelation($viaName, $model);
                $viaModels = $model === null ? [] : [$model];
            }
            $this->filterByModels($viaModels);
        } else {
            $this->filterByModels([$this->primaryModel]);
        }
    }
    /* @var $modelClass ActiveRecord */
    $modelClass = $this->modelClass;
    if ($db === null) {
        $db = $modelClass::getDb();
    }
    // find by primary key if possible. This is much faster than scanning all records
    if (
        is_array($this->where)
        && (
            (!isset($this->where[0]) && $modelClass::isPrimaryKey(array_keys($this->where)))
            || (isset($this->where[0]) && $this->where[0] === 'in' && $modelClass::isPrimaryKey((array) $this->where[1]))
        )
    ) {
        return $this->findByPk($db, $type, $columnName);
    }
    $method = 'build' . $type;
    $script = $db->getLuaScriptBuilder()->$method($this, $columnName);
    return $db->executeCommand('EVAL', [$script, 0]);
}

            

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

            

                public function init()
{
    parent::init();
    $this->trigger(self::EVENT_INIT);
}

            

                public function max($column, $db = null)
{
    if ($this->emulateExecution) {
        return null;
    }
    return $this->executeScript($db, 'Max', $column);
}

            

                public function min($column, $db = null)
{
    if ($this->emulateExecution) {
        return null;
    }
    return $this->executeScript($db, 'Min', $column);
}

            

                public function one($db = null)
{
    if ($this->emulateExecution) {
        return null;
    }
    // TODO add support for orderBy
    $data = $this->executeScript($db, 'One');
    if (empty($data)) {
        return null;
    }
    $row = [];
    $c = count($data);
    for ($i = 0; $i < $c;) {
        $row[$data[$i++]] = $data[$i++];
    }
    if ($this->asArray) {
        $model = $row;
    } else {
        /* @var $class ActiveRecord */
        $class = $this->modelClass;
        $model = $class::instantiate($row);
        $class = get_class($model);
        $class::populateRecord($model, $row);
    }
    if (!empty($this->with)) {
        $models = [$model];
        $this->findWith($this->with, $models);
        $model = $models[0];
    }
    if (!$this->asArray) {
        $model->afterFind();
    }
    return $model;
}

            

                public function scalar($attribute, $db = null)
{
    if ($this->emulateExecution) {
        return null;
    }
    $record = $this->one($db);
    if ($record !== null) {
        return $record->hasAttribute($attribute) ? $record->$attribute : null;
    }
    return null;
}

            

                public function sum($column, $db = null)
{
    if ($this->emulateExecution) {
        return 0;
    }
    return $this->executeScript($db, 'Sum', $column);
}