Class yii\sphinx\Schema

                protected function applyDefaultColumns($index)
{
    $column = $this->loadColumnSchema([
        'Field' => 'id',
        'Type' => 'bigint',
    ]);
    $index->columns[$column->name] = $column;
    $index->primaryKey = 'id';
}

            

                public function convertException(\Exception $e, $rawSql)
{
    if ($e instanceof Exception) {
        return $e;
    }
    $message = $e->getMessage()  . "\nThe SQL being executed was: $rawSql";
    $errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
    return new Exception($message, $errorInfo, (int) $e->getCode(), $e);
}

            

                public function createQueryBuilder()
{
    return new QueryBuilder($this->db);
}

            

                protected function findColumns($index)
{
    $sql = 'DESCRIBE ' . $this->quoteSimpleIndexName($index->name);
    try {
        $columns = $this->db->createCommand($sql)->queryAll();
    } catch (\Exception $e) {
        $previous = $e->getPrevious();
        if ($previous instanceof \PDOException && strpos($previous->getMessage(), 'SQLSTATE[42S02') !== false) {
            // index does not exist
            // https://dev.mysql.com/doc/refman/5.5/en/error-messages-server.html#error_er_bad_table_error
            return false;
        }
        throw $e;
    }
    if (empty($columns[0]['Agent'])) {
        foreach ($columns as $info) {
            $column = $this->loadColumnSchema($info);
            if (isset($index->columns[$column->name])) {
                $column = $this->mergeColumnSchema($index->columns[$column->name], $column);
            }
            $index->columns[$column->name] = $column;
            if ($column->isPrimaryKey) {
                $index->primaryKey = $column->name;
            }
        }
        return true;
    }
    // Distributed index :
    foreach ($columns as $column) {
        if (!empty($column['Type']) && strcasecmp('local', $column['Type']) !== 0) {
            // skip type 'agent'
            continue;
        }
        $agent = $this->getIndexSchema($column['Agent']);
        if ($agent !== null) {
            $index->columns = $agent->columns;
            $index->primaryKey = $agent->primaryKey;
            return true;
        }
    }
    $this->applyDefaultColumns($index);
    return true;
}

            

                protected function findIndexes()
{
    $sql = 'SHOW TABLES';
    return $this->db->createCommand($sql)->queryAll();
}

            

                protected function getCacheKey($name)
{
    return [
        __CLASS__,
        $this->db->dsn,
        $this->db->username,
        $name,
    ];
}

            

                protected function getCacheTag()
{
    return md5(serialize([
        __CLASS__,
        $this->db->dsn,
        $this->db->username,
    ]));
}

            

                protected function getColumnPhpType($column)
{
    static $typeMap = [ // abstract type => php type
        'smallint' => 'integer',
        'integer' => 'integer',
        'bigint' => 'integer',
        'timestamp' => 'integer',
        'boolean' => 'boolean',
        'float' => 'double',
    ];
    if (isset($typeMap[$column->type])) {
        if ($column->type === 'bigint') {
            return PHP_INT_SIZE == 8 ? 'integer' : 'string';
        } elseif ($column->type === 'integer' || $column->type === 'timestamp') {
            return PHP_INT_SIZE == 4 ? 'string' : 'integer';
        } else {
            return $typeMap[$column->type];
        }
    } else {
        return 'string';
    }
}

            

                public function getIndexNames($refresh = false)
{
    if (!isset($this->_indexNames) || $refresh) {
        $this->initIndexesInfo();
    }
    return $this->_indexNames;
}

            

                public function getIndexSchema($name, $refresh = false)
{
    if (isset($this->_indexes[$name]) && !$refresh) {
        return $this->_indexes[$name];
    }
    $db = $this->db;
    $realName = $this->getRawIndexName($name);
    if ($db->enableSchemaCache && !in_array($name, $db->schemaCacheExclude, true)) {
        /* @var $cache Cache */
        $cache = is_string($db->schemaCache) ? Yii::$app->get($db->schemaCache, false) : $db->schemaCache;
        if ($cache instanceof Cache) {
            $key = $this->getCacheKey($name);
            if ($refresh || ($index = $cache->get($key)) === false) {
                $index = $this->loadIndexSchema($realName);
                if ($index !== null) {
                    $cache->set($key, $index, $db->schemaCacheDuration, new TagDependency([
                        'tags' => $this->getCacheTag(),
                    ]));
                }
            }
            return $this->_indexes[$name] = $index;
        }
    }
    return $this->_indexes[$name] = $this->loadIndexSchema($realName);
}

            

                public function getIndexSchemas($refresh = false)
{
    $indexes = [];
    foreach ($this->getIndexNames($refresh) as $name) {
        if (($index = $this->getIndexSchema($name, $refresh)) !== null) {
            $indexes[] = $index;
        }
    }
    return $indexes;
}

            

                public function getIndexTypes($refresh = false)
{
    if (!isset($this->_indexTypes) || $refresh) {
        $this->initIndexesInfo();
    }
    return $this->_indexTypes;
}

            

                public function getPdoType($data)
{
    static $typeMap = [
        // php type => PDO type
        'bool' => \PDO::PARAM_BOOL,
        'boolean' => \PDO::PARAM_BOOL,
        'int' => \PDO::PARAM_INT,
        'integer' => \PDO::PARAM_INT,
        'string' => \PDO::PARAM_STR,
        'resource' => \PDO::PARAM_LOB,
        'NULL' => \PDO::PARAM_NULL,
    ];
    $type = gettype($data);
    return isset($typeMap[$type]) ? $typeMap[$type] : \PDO::PARAM_STR;
}

            

                public function getQueryBuilder()
{
    if ($this->_builder === null) {
        $this->_builder = $this->createQueryBuilder();
    }
    return $this->_builder;
}

            

                public function getRawIndexName($name)
{
    if (strpos($name, '{{') !== false) {
        $name = preg_replace('/\\{\\{(.*?)\\}\\}/', '\1', $name);
        return str_replace('%', $this->db->tablePrefix, $name);
    } else {
        return $name;
    }
}

            

                protected function initIndexesInfo()
{
    $this->_indexNames = [];
    $this->_indexTypes = [];
    $indexes = $this->findIndexes();
    foreach ($indexes as $index) {
        $indexName = $index['Index'];
        $this->_indexNames[] = $indexName;
        $this->_indexTypes[$indexName] = $index['Type'];
    }
}

            

                public function isReadQuery($sql)
{
    $pattern = '/^\s*(SELECT|SHOW|DESCRIBE)\b/i';
    return preg_match($pattern, $sql) > 0;
}

            

                protected function loadColumnSchema($info)
{
    $column = new ColumnSchema();
    $column->name = $info['Field'];
    $column->dbType = $info['Type'];
    $column->isPrimaryKey = ($column->name === 'id');
    $type = $info['Type'];
    if (isset($this->typeMap[$type])) {
        $column->type = $this->typeMap[$type];
    } else {
        $column->type = self::TYPE_STRING;
    }
    $column->isField = ($type === 'field');
    $column->isAttribute = !$column->isField;
    $column->isMva = ($type === 'mva');
    $column->phpType = $this->getColumnPhpType($column);
    return $column;
}

            

                protected function loadIndexSchema($name)
{
    $index = new IndexSchema();
    $this->resolveIndexNames($index, $name);
    $this->resolveIndexType($index);
    if ($this->findColumns($index)) {
        return $index;
    }
    return null;
}

            

                protected function mergeColumnSchema($origin, $override)
{
    $override->dbType .= ',' . $override->dbType;
    if ($override->isField) {
        $origin->isField = true;
    }
    if ($override->isAttribute) {
        $origin->isAttribute = true;
        $origin->type = $override->type;
        $origin->phpType = $override->phpType;
        if ($override->isMva) {
            $origin->isMva = true;
        }
    }
    return $origin;
}

            

                public function quoteColumnName($name)
{
    if (strpos($name, '(') !== false || strpos($name, '[[') !== false || strpos($name, '{{') !== false) {
        return $name;
    }
    if (($pos = strrpos($name, '.')) !== false) {
        $prefix = $this->quoteIndexName(substr($name, 0, $pos)) . '.';
        $name = substr($name, $pos + 1);
    } else {
        $prefix = '';
    }
    return $prefix . $this->quoteSimpleColumnName($name);
}

            

                public function quoteIndexName($name)
{
    if (strpos($name, '(') !== false || strpos($name, '{{') !== false) {
        return $name;
    }
    return $this->quoteSimpleIndexName($name);
}

            

                public function quoteSimpleColumnName($name)
{
    return strpos($name, '`') !== false || $name === '*' ? $name : '`' . $name . '`';
}

            

                public function quoteSimpleIndexName($name)
{
    return strpos($name, "`") !== false ? $name : "`" . $name . "`";
}

            

                public function quoteValue($str)
{
    if (is_string($str)) {
        return $this->db->getSlavePdo()->quote($str);
    }
    return $str;
}

            

                public function refresh()
{
    /* @var $cache Cache */
    $cache = is_string($this->db->schemaCache) ? Yii::$app->get($this->db->schemaCache, false) : $this->db->schemaCache;
    if ($this->db->enableSchemaCache && $cache instanceof Cache) {
        TagDependency::invalidate($cache, $this->getCacheTag());
    }
    $this->_indexNames = [];
    $this->_indexes = [];
}

            

                protected function resolveIndexNames($index, $name)
{
    $index->name = str_replace('`', '', $name);
}

            

                protected function resolveIndexType($index)
{
    $indexTypes = $this->getIndexTypes();
    $index->type = array_key_exists($index->name, $indexTypes) ? $indexTypes[$index->name] : 'unknown';
    $index->isRt = ($index->type == 'rt');
}