Class yii\sphinx\ActiveQuery

                public function addFacets($facets)
{
    if (is_array($this->facets)) {
        $this->facets = array_merge($this->facets, $facets);
    } else {
        $this->facets = $facets;
    }
    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 addWithin($columns)
{
    $columns = $this->normalizeOrderBy($columns);
    if ($this->within === null) {
        $this->within = $columns;
    } else {
        $this->within = array_merge($this->within, $columns);
    }
    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 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,
    ]);
}

            

                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;
}

            

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

            

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

            

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

            

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

            

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

            

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

            

                protected function queryScalar($selectExpression, $db)
{
    if (!empty($this->emulateExecution)) {
        return null;
    }
    $select = $this->select;
    $limit = $this->limit;
    $offset = $this->offset;
    $this->select = [$selectExpression];
    $this->limit = null;
    $this->offset = null;
    $command = $this->createCommand($db);
    $this->select = $select;
    $this->limit = $limit;
    $this->offset = $offset;
    if (empty($this->groupBy) && empty($this->union) && !$this->distinct) {
        return $command->queryScalar();
    }
    return (new Query)->select([$selectExpression])
        ->from(['c' => $this])
        ->createCommand($command->db)
        ->queryScalar();
}

            

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

            

                public function search($db = null)
{
    if (!empty($this->emulateExecution)) {
        return [
            'hits' => [],
            'facets' => [],
            'meta' => [],
        ];
    }
    $command = $this->createCommand($db);
    $dataReader = $command->query();
    $rawRows = $dataReader->readAll();
    $facets = [];
    foreach ($this->facets as $facetKey => $facetValue) {
        $dataReader->nextResult();
        $rawFacetResults = $dataReader->readAll();
        if (is_numeric($facetKey)) {
            $facet = [
                'name' => $facetValue,
                'value' => $facetValue,
                'count' => 'count(*)',
            ];
        } else {
            $facet = array_merge(
                [
                    'name' => $facetKey,
                    'value' => $facetKey,
                    'count' => 'count(*)',
                ],
                $facetValue
            );
        }
        foreach ($rawFacetResults as $rawFacetResult) {
            $rawFacetResult['value'] = isset($rawFacetResult[strtolower($facet['value'])]) ? $rawFacetResult[strtolower($facet['value'])] : null;
            $rawFacetResult['count'] = $rawFacetResult[$facet['count']];
            $facets[$facet['name']][] = $rawFacetResult;
        }
    }
    $meta = [];
    if (!empty($this->showMeta)) {
        $dataReader->nextResult();
        $rawMetaResults = $dataReader->readAll();
        foreach ($rawMetaResults as $rawMetaResult) {
            $meta[$rawMetaResult['Variable_name']] = $rawMetaResult['Value'];
        }
    }
    // rows should be populated after all data read from cursor, avoiding possible 'unbuffered query' error
    $rows = $this->populate($rawRows);
    return [
        'hits' => $rows,
        'facets' => $facets,
        'meta' => $meta,
    ];
}

            

                public function setConnection($connection)
{
    $this->_connection = $connection;
    return $this;
}

            

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

            

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

            

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

            

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