Class yii\sphinx\ActiveQuery

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    parent::__clone();
    // make a clone of "via" object so that the same query object can be reused multiple times
    if (is_object($this->via)) {
        $this->via = clone $this->via;
    } elseif (is_array($this->via)) {
        $this->via = [$this->via[0], clone $this->via[1], $this->via[2]];
    }
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

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

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function addFacets($facets)
{
    if (is_array($this->facets)) {
        $this->facets = array_merge($this->facets, $facets);
    } else {
        $this->facets = $facets;
    }
    return $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 addOptions($options)
{
    if (is_array($this->options)) {
        $this->options = array_merge($this->options, $options);
    } else {
        $this->options = $options;
    }
    return $this;
}

            

                public function addOrderBy($columns)
{
    $columns = $this->normalizeOrderBy($columns);
    if ($this->orderBy === null) {
        $this->orderBy = $columns;
    } else {
        $this->orderBy = array_merge($this->orderBy, $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 addWithin($columns)
{
    $columns = $this->normalizeOrderBy($columns);
    if ($this->within === null) {
        $this->within = $columns;
    } else {
        $this->within = array_merge($this->within, $columns);
    }
    return $this;
}

            

                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 andFilterWhere(array $condition)
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->andWhere($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)
{
    if ($this->where === null) {
        $this->where = $condition;
    } else {
        $this->where = ['and', $this->where, $condition];
    }
    return $this;
}

            

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

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                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 behaviors()
{
    return [];
}

            

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

            

                protected function callSnippetsInternal(array $source, $from)
{
    $connection = $this->getConnection();
    $match = $this->match;
    if ($match === null) {
        throw new InvalidCallException('Unable to call snippets: "' . $this->className() . '::match" should be specified.');
    }
    return $connection->createCommand()
        ->callSnippets($from, $source, $match, $this->snippetOptions)
        ->queryColumn();
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                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,
        // Sphinx specifics :
        'groupLimit' => $from->groupLimit,
        'options' => $from->options,
        'within' => $from->within,
        'match' => $from->match,
        'snippetCallback' => $from->snippetCallback,
        'snippetOptions' => $from->snippetOptions,
    ]);
}

            

                protected function createModels($rows)
{
    if ($this->asArray) {
        return $rows;
    } else {
        $models = [];
        /* @var $class ActiveRecord */
        $class = $this->modelClass;
        foreach ($rows as $row) {
            $model = $class::instantiate($row);
            $modelClass = get_class($model);
            $modelClass::populateRecord($model, $row);
            $models[] = $model;
        }
        return $models;
    }
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                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 emulateExecution($value = true)
{
    $this->emulateExecution = $value;
    return $this;
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                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 facets($facets)
{
    $this->facets = $facets;
    return $this;
}

            

                protected function fillUpSnippets($rows)
{
    if ($this->snippetCallback === null || empty($rows)) {
        return $rows;
    }
    $snippetSources = call_user_func($this->snippetCallback, $rows);
    $snippets = $this->callSnippets($snippetSources);
    $snippetKey = 0;
    foreach ($rows as $key => $row) {
        $rows[$key]['snippet'] = $snippets[$snippetKey];
        $snippetKey++;
    }
    return $rows;
}

            

                protected function filterCondition($condition)
{
    if (!is_array($condition)) {
        return $condition;
    }
    if (!isset($condition[0])) {
        // hash format: 'column1' => 'value1', 'column2' => 'value2', ...
        foreach ($condition as $name => $value) {
            if ($this->isEmpty($value)) {
                unset($condition[$name]);
            }
        }
        return $condition;
    }
    // operator format: operator, operand 1, operand 2, ...
    $operator = array_shift($condition);
    switch (strtoupper($operator)) {
        case 'NOT':
        case 'AND':
        case 'OR':
            foreach ($condition as $i => $operand) {
                $subCondition = $this->filterCondition($operand);
                if ($this->isEmpty($subCondition)) {
                    unset($condition[$i]);
                } else {
                    $condition[$i] = $subCondition;
                }
            }
            if (empty($condition)) {
                return [];
            }
            break;
        case 'BETWEEN':
        case 'NOT BETWEEN':
            if (array_key_exists(1, $condition) && array_key_exists(2, $condition)) {
                if ($this->isEmpty($condition[1]) || $this->isEmpty($condition[2])) {
                    return [];
                }
            }
            break;
        default:
            if (array_key_exists(1, $condition) && $this->isEmpty($condition[1])) {
                return [];
            }
    }
    array_unshift($condition, $operator);
    return $condition;
}

            

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

            

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

            

                public function findFor($name, $model)
{
    if (method_exists($model, 'get' . $name)) {
        $method = new \ReflectionMethod($model, 'get' . $name);
        $realName = lcfirst(substr($method->getName(), 3));
        if ($realName !== $name) {
            throw new InvalidArgumentException('Relation names are case sensitive. ' . get_class($model) . " has a relation named \"$realName\" instead of \"$name\".");
        }
    }
    return $this->multiple ? $this->all() : $this->one();
}

            

                public function findWith($with, &$models)
{
    if (empty($models)) {
        return;
    }
    $primaryModel = reset($models);
    if (!$primaryModel instanceof ActiveRecordInterface) {
        /* @var $modelClass ActiveRecordInterface */
        $modelClass = $this->modelClass;
        $primaryModel = $modelClass::instance();
    }
    $relations = $this->normalizeRelations($primaryModel, $with);
    /* @var $relation ActiveQuery */
    foreach ($relations as $name => $relation) {
        if ($relation->asArray === null) {
            // inherit asArray from primary query
            $relation->asArray($this->asArray);
        }
        $relation->populateRelation($name, $models);
    }
}

            

                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 getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getConnection()
{
    if ($this->_connection === null) {
        $this->_connection = $this->defaultConnection();
    }
    return $this->_connection;
}

            

                public function getTablesUsedInFrom()
{
    // feature not supported, returning a stub:
    return [];
}

            

                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 groupLimit($limit)
{
    $this->groupLimit = $limit;
    return $this;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

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

            

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

            

                public function innerJoin($table, $on = '', $params = [])
{
    throw new NotSupportedException('"' . __METHOD__ . '" is not supported.');
}

            

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

            

                protected function isEmpty($value)
{
    return $value === '' || $value === [] || $value === null || is_string($value) && trim($value) === '';
}

            

                public function join($type, $table, $on = '', $params = [])
{
    throw new NotSupportedException('"' . __METHOD__ . '" is not supported.');
}

            

                public function leftJoin($table, $on = '', $params = [])
{
    throw new NotSupportedException('"' . __METHOD__ . '" is not supported.');
}

            

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

            

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

            

                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 normalizeOrderBy($columns)
{
    if (empty($columns)) {
        return [];
    } elseif ($columns instanceof ExpressionInterface) {
        return [$columns];
    } elseif (is_array($columns)) {
        return $columns;
    }
    $columns = preg_split('/\s*,\s*/', trim($columns), -1, PREG_SPLIT_NO_EMPTY);
    $result = [];
    foreach ($columns as $column) {
        if (preg_match('/^(.*?)\s+(asc|desc)$/i', $column, $matches)) {
            $result[$matches[1]] = strcasecmp($matches[2], 'desc') ? SORT_ASC : SORT_DESC;
        } else {
            $result[$column] = SORT_ASC;
        }
    }
    return $result;
}

            

                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 off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

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

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

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

            

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

            

                public function orFilterWhere(array $condition)
{
    $condition = $this->filterCondition($condition);
    if ($condition !== []) {
        $this->orWhere($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)
{
    if ($this->where === null) {
        $this->where = $condition;
    } else {
        $this->where = ['or', $this->where, $condition];
    }
    return $this;
}

            

                public function orderBy($columns)
{
    $this->orderBy = $this->normalizeOrderBy($columns);
    return $this;
}

            

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

            

                public function populateRelation($name, &$primaryModels)
{
    if (!is_array($this->link)) {
        throw new InvalidConfigException('Invalid link: it must be an array of key-value pairs.');
    }
    if ($this->via instanceof self) {
        // via junction table
        /* @var $viaQuery ActiveRelationTrait */
        $viaQuery = $this->via;
        $viaModels = $viaQuery->findJunctionRows($primaryModels);
        $this->filterByModels($viaModels);
    } elseif (is_array($this->via)) {
        // via relation
        /* @var $viaQuery ActiveRelationTrait|ActiveQueryTrait */
        list($viaName, $viaQuery) = $this->via;
        if ($viaQuery->asArray === null) {
            // inherit asArray from primary query
            $viaQuery->asArray($this->asArray);
        }
        $viaQuery->primaryModel = null;
        $viaModels = array_filter($viaQuery->populateRelation($viaName, $primaryModels));
        $this->filterByModels($viaModels);
    } else {
        $this->filterByModels($primaryModels);
    }
    if (!$this->multiple && count($primaryModels) === 1) {
        $model = $this->one();
        $primaryModel = reset($primaryModels);
        if ($primaryModel instanceof ActiveRecordInterface) {
            $primaryModel->populateRelation($name, $model);
        } else {
            $primaryModels[key($primaryModels)][$name] = $model;
        }
        if ($this->inverseOf !== null) {
            $this->populateInverseRelation($primaryModels, [$model], $name, $this->inverseOf);
        }
        return [$model];
    }
    // https://github.com/yiisoft/yii2/issues/3197
    // delay indexing related models after buckets are built
    $indexBy = $this->indexBy;
    $this->indexBy = null;
    $models = $this->all();
    if (isset($viaModels, $viaQuery)) {
        $buckets = $this->buildBuckets($models, $this->link, $viaModels, $viaQuery);
    } else {
        $buckets = $this->buildBuckets($models, $this->link);
    }
    $this->indexBy = $indexBy;
    if ($this->indexBy !== null && $this->multiple) {
        $buckets = $this->indexBuckets($buckets, $this->indexBy);
    }
    $link = array_values($this->link);
    if (isset($viaQuery)) {
        $deepViaQuery = $viaQuery;
        while ($deepViaQuery->via) {
            $deepViaQuery = is_array($deepViaQuery->via) ? $deepViaQuery->via[1] : $deepViaQuery->via;
        };
        $link = array_values($deepViaQuery->link);
    }
    foreach ($primaryModels as $i => $primaryModel) {
        $keys = null;
        if ($this->multiple && count($link) === 1) {
            $primaryModelKey = reset($link);
            $keys = isset($primaryModel[$primaryModelKey]) ? $primaryModel[$primaryModelKey] : null;
        }
        if (is_array($keys)) {
            $value = [];
            foreach ($keys as $key) {
                $key = $this->normalizeModelKey($key);
                if (isset($buckets[$key])) {
                    if ($this->indexBy !== null) {
                        // if indexBy is set, array_merge will cause renumbering of numeric array
                        foreach ($buckets[$key] as $bucketKey => $bucketValue) {
                            $value[$bucketKey] = $bucketValue;
                        }
                    } else {
                        $value = array_merge($value, $buckets[$key]);
                    }
                }
            }
        } else {
            $key = $this->getModelKey($primaryModel, $link);
            $value = isset($buckets[$key]) ? $buckets[$key] : ($this->multiple ? [] : null);
        }
        if ($primaryModel instanceof ActiveRecordInterface) {
            $primaryModel->populateRelation($name, $value);
        } else {
            $primaryModels[$i][$name] = $value;
        }
    }
    if ($this->inverseOf !== null) {
        $this->populateInverseRelation($primaryModels, $models, $name, $this->inverseOf);
    }
    return $models;
}