Abstract Class yii\db\Schema

                public function convertException(\Exception $e, $rawSql)
{
    if ($e instanceof Exception) {
        return $e;
    }
    $exceptionClass = '\yii\db\Exception';
    foreach ($this->exceptionMap as $error => $class) {
        if (strpos($e->getMessage(), $error) !== false) {
            $exceptionClass = $class;
        }
    }
    $message = $e->getMessage() . "\nThe SQL being executed was: $rawSql";
    $errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
    return new $exceptionClass($message, $errorInfo, $e->getCode(), $e);
}

            

                protected function createColumnSchema()
{
    return Yii::createObject($this->columnSchemaClass);
}

            

                public function createColumnSchemaBuilder($type, $length = null)
{
    return new ColumnSchemaBuilder($type, $length);
}

            

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

            

                public function createSavepoint($name)
{
    $this->db->createCommand("SAVEPOINT $name")->execute();
}

            

                protected function findSchemaNames()
{
    throw new NotSupportedException(get_class($this) . ' does not support fetching all schema names.');
}

            

                protected function findTableNames($schema = '')
{
    throw new NotSupportedException(get_class($this) . ' does not support fetching all table names.');
}

            

                public function findUniqueIndexes($table)
{
    throw new NotSupportedException(get_class($this) . ' does not support getting unique indexes information.');
}

            

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

            

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

            

                protected function getColumnPhpType($column)
{
    static $typeMap = [
        // abstract type => php type
        self::TYPE_TINYINT => 'integer',
        self::TYPE_SMALLINT => 'integer',
        self::TYPE_INTEGER => 'integer',
        self::TYPE_BIGINT => 'integer',
        self::TYPE_BOOLEAN => 'boolean',
        self::TYPE_FLOAT => 'double',
        self::TYPE_DOUBLE => 'double',
        self::TYPE_BINARY => 'resource',
        self::TYPE_JSON => 'array',
    ];
    if (isset($typeMap[$column->type])) {
        if ($column->type === 'bigint') {
            return PHP_INT_SIZE === 8 && !$column->unsigned ? 'integer' : 'string';
        } elseif ($column->type === 'integer') {
            return PHP_INT_SIZE === 4 && $column->unsigned ? 'string' : 'integer';
        }
        return $typeMap[$column->type];
    }
    return 'string';
}

            

                public function getLastInsertID($sequenceName = '')
{
    if ($this->db->isActive) {
        return $this->db->pdo->lastInsertId($sequenceName === '' ? null : $this->quoteTableName($sequenceName));
    }
    throw new InvalidCallException('DB Connection is not active.');
}

            

                public function getPdoType($data)
{
    static $typeMap = [
        // php type => PDO type
        'boolean' => \PDO::PARAM_BOOL,
        '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 getRawTableName($name)
{
    if (strpos($name, '{{') !== false) {
        $name = preg_replace('/\\{\\{(.*?)\\}\\}/', '\1', $name);
        return str_replace('%', $this->db->tablePrefix, $name);
    }
    return $name;
}

            

                protected function getSchemaMetadata($schema, $type, $refresh)
{
    $metadata = [];
    $methodName = 'getTable' . ucfirst($type);
    foreach ($this->getTableNames($schema, $refresh) as $name) {
        if ($schema !== '') {
            $name = $schema . '.' . $name;
        }
        $tableMetadata = $this->$methodName($name, $refresh);
        if ($tableMetadata !== null) {
            $metadata[] = $tableMetadata;
        }
    }
    return $metadata;
}

            

                public function getSchemaNames($refresh = false)
{
    if ($this->_schemaNames === null || $refresh) {
        $this->_schemaNames = $this->findSchemaNames();
    }
    return $this->_schemaNames;
}

            

                public function getServerVersion()
{
    if ($this->_serverVersion === null) {
        $this->_serverVersion = $this->db->getSlavePdo()->getAttribute(\PDO::ATTR_SERVER_VERSION);
    }
    return $this->_serverVersion;
}

            

                protected function getTableMetadata($name, $type, $refresh)
{
    $cache = null;
    if ($this->db->enableSchemaCache && !in_array($name, $this->db->schemaCacheExclude, true)) {
        $schemaCache = is_string($this->db->schemaCache) ? Yii::$app->get($this->db->schemaCache, false) : $this->db->schemaCache;
        if ($schemaCache instanceof CacheInterface) {
            $cache = $schemaCache;
        }
    }
    $rawName = $this->getRawTableName($name);
    if (!isset($this->_tableMetadata[$rawName])) {
        $this->loadTableMetadataFromCache($cache, $rawName);
    }
    if ($refresh || !array_key_exists($type, $this->_tableMetadata[$rawName])) {
        $this->_tableMetadata[$rawName][$type] = $this->{'loadTable' . ucfirst($type)}($rawName);
        $this->saveTableMetadataToCache($cache, $rawName);
    }
    return $this->_tableMetadata[$rawName][$type];
}

            

                protected function getTableNameParts($name)
{
    return explode('.', $name);
}

            

                public function getTableNames($schema = '', $refresh = false)
{
    if (!isset($this->_tableNames[$schema]) || $refresh) {
        $this->_tableNames[$schema] = $this->findTableNames($schema);
    }
    return $this->_tableNames[$schema];
}

            

                public function getTableSchema($name, $refresh = false)
{
    return $this->getTableMetadata($name, 'schema', $refresh);
}

            

                public function getTableSchemas($schema = '', $refresh = false)
{
    return $this->getSchemaMetadata($schema, 'schema', $refresh);
}

            

                public function insert($table, $columns)
{
    $command = $this->db->createCommand()->insert($table, $columns);
    if (!$command->execute()) {
        return false;
    }
    $tableSchema = $this->getTableSchema($table);
    $result = [];
    foreach ($tableSchema->primaryKey as $name) {
        if ($tableSchema->columns[$name]->autoIncrement) {
            $result[$name] = $this->getLastInsertID($tableSchema->sequenceName);
            break;
        }
        $result[$name] = isset($columns[$name]) ? $columns[$name] : $tableSchema->columns[$name]->defaultValue;
    }
    return $result;
}

            

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

            

                abstract protected function loadTableSchema($name);

            

                protected function normalizePdoRowKeyCase(array $row, $multiple)
{
    if ($this->db->getSlavePdo()->getAttribute(\PDO::ATTR_CASE) !== \PDO::CASE_UPPER) {
        return $row;
    }
    if ($multiple) {
        return array_map(function (array $row) {
            return array_change_key_case($row, CASE_LOWER);
        }, $row);
    }
    return array_change_key_case($row, CASE_LOWER);
}

            

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

            

                public function quoteSimpleColumnName($name)
{
    if (is_string($this->columnQuoteCharacter)) {
        $startingCharacter = $endingCharacter = $this->columnQuoteCharacter;
    } else {
        list($startingCharacter, $endingCharacter) = $this->columnQuoteCharacter;
    }
    return $name === '*' || strpos($name, $startingCharacter) !== false ? $name : $startingCharacter . $name . $endingCharacter;
}

            

                public function quoteSimpleTableName($name)
{
    if (is_string($this->tableQuoteCharacter)) {
        $startingCharacter = $endingCharacter = $this->tableQuoteCharacter;
    } else {
        list($startingCharacter, $endingCharacter) = $this->tableQuoteCharacter;
    }
    return strpos($name, $startingCharacter) !== false ? $name : $startingCharacter . $name . $endingCharacter;
}

            

                public function quoteTableName($name)
{
    if (strncmp($name, '(', 1) === 0 && strpos($name, ')') === strlen($name) - 1) {
        return $name;
    }
    if (strpos($name, '{{') !== false) {
        return $name;
    }
    if (strpos($name, '.') === false) {
        return $this->quoteSimpleTableName($name);
    }
    $parts = $this->getTableNameParts($name);
    foreach ($parts as $i => $part) {
        $parts[$i] = $this->quoteSimpleTableName($part);
    }
    return implode('.', $parts);
}

            

                public function quoteValue($str)
{
    if (!is_string($str)) {
        return $str;
    }
    if (mb_stripos($this->db->dsn, 'odbc:') === false && ($value = $this->db->getSlavePdo()->quote($str)) !== false) {
        return $value;
    }
    // the driver doesn't support quote (e.g. oci)
    return "'" . addcslashes(str_replace("'", "''", $str), "\000\n\r\\\032") . "'";
}

            

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

            

                public function refreshTableSchema($name)
{
    $rawName = $this->getRawTableName($name);
    unset($this->_tableMetadata[$rawName]);
    $this->_tableNames = [];
    /* @var $cache CacheInterface */
    $cache = is_string($this->db->schemaCache) ? Yii::$app->get($this->db->schemaCache, false) : $this->db->schemaCache;
    if ($this->db->enableSchemaCache && $cache instanceof CacheInterface) {
        $cache->delete($this->getCacheKey($rawName));
    }
}

            

                public function releaseSavepoint($name)
{
    $this->db->createCommand("RELEASE SAVEPOINT $name")->execute();
}

            

                protected function resolveTableName($name)
{
    throw new NotSupportedException(get_class($this) . ' does not support resolving table names.');
}

            

                public function rollBackSavepoint($name)
{
    $this->db->createCommand("ROLLBACK TO SAVEPOINT $name")->execute();
}

            

                protected function setTableMetadata($name, $type, $data)
{
    $this->_tableMetadata[$this->getRawTableName($name)][$type] = $data;
}

            

                public function setTransactionIsolationLevel($level)
{
    $this->db->createCommand("SET TRANSACTION ISOLATION LEVEL $level")->execute();
}

            

                public function supportsSavepoint()
{
    return $this->db->enableSavepoint;
}

            

                public function unquoteSimpleColumnName($name)
{
    if (is_string($this->columnQuoteCharacter)) {
        $startingCharacter = $this->columnQuoteCharacter;
    } else {
        $startingCharacter = $this->columnQuoteCharacter[0];
    }
    return strpos($name, $startingCharacter) === false ? $name : substr($name, 1, -1);
}

            

                public function unquoteSimpleTableName($name)
{
    if (is_string($this->tableQuoteCharacter)) {
        $startingCharacter = $this->tableQuoteCharacter;
    } else {
        $startingCharacter = $this->tableQuoteCharacter[0];
    }
    return strpos($name, $startingCharacter) === false ? $name : substr($name, 1, -1);
}