Class yii\db\mssql\Schema

                public function createColumnSchemaBuilder($type, $length = null)
{
    return Yii::createObject(ColumnSchemaBuilder::class, [$type, $length, $this->db]);
}

            

                public function createQueryBuilder()
{
    return Yii::createObject(QueryBuilder::class, [$this->db]);
}

            

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

            

                protected function findColumns($table)
{
    $systemCatalogName = $this->quoteSystemCatalogName($table->catalogName);
    $sql = <<<SQL
    SELECT
        [c].[name] AS [column_name],
        CASE WHEN [c].[is_nullable] = 1 THEN 'YES' ELSE 'NO' END AS [is_nullable],
        CASE
            WHEN [t].[name] IN ('char','varchar','nchar','nvarchar','binary','varbinary') THEN
                CASE
                    WHEN [c].[max_length] = -1 AND [t].[name] IN ('varchar','nvarchar','varbinary') THEN
                        [t].[name] + '(max)'
                    WHEN [t].[name] IN ('nchar','nvarchar') THEN
                        [t].[name] + '(' + CAST([c].[max_length] / 2 AS VARCHAR) + ')'
                    ELSE
                        [t].[name] + '(' + CAST([c].[max_length] AS VARCHAR) + ')'
                END
            WHEN [t].[name] IN ('decimal','numeric') THEN
                [t].[name] + '(' + CAST([c].[precision] AS VARCHAR) + ',' + CAST([c].[scale] AS VARCHAR) + ')'
            ELSE [t].[name]
        END AS [data_type],
        [dc].[definition] AS [column_default],
        [c].[is_identity],
        [c].[is_computed],
        CAST([ep].[value] AS NVARCHAR(MAX)) AS [comment]
    FROM {$systemCatalogName}.[columns] AS [c]
    INNER JOIN {$systemCatalogName}.[types] AS [t]
        ON [c].[system_type_id] = [t].[system_type_id]
        AND [t].[user_type_id] = [t].[system_type_id]
    LEFT JOIN {$systemCatalogName}.[default_constraints] AS [dc]
        ON [dc].[object_id] = [c].[default_object_id]
    LEFT JOIN {$systemCatalogName}.[extended_properties] AS [ep]
        ON [ep].[major_id] = [c].[object_id]
        AND [ep].[minor_id] = [c].[column_id]
        AND [ep].[class] = 1
        AND [ep].[name] = 'MS_Description'
    WHERE [c].[object_id] = OBJECT_ID(:fullName)
    ORDER BY [c].[column_id]
    SQL;
    $columns = $this->db->createCommand(
        $sql,
        [':fullName' => $this->quoteTableFullName($table)],
    )->queryAll();
    if (empty($columns)) {
        return false;
    }
    foreach ($columns as $column) {
        $column = $this->loadColumnSchema($column);
        foreach ($table->primaryKey as $primaryKey) {
            if (strcasecmp($column->name, $primaryKey) === 0) {
                $column->isPrimaryKey = true;
                break;
            }
        }
        if ($column->isPrimaryKey && $column->autoIncrement) {
            $table->sequenceName = '';
        }
        $column->defaultValue = $column->isPrimaryKey && $column->autoIncrement
            ? null
            : $column->defaultPhpTypecast($column->defaultValue);
        $table->columns[$column->name] = $column;
    }
    return true;
}

            

                protected function findForeignKeys($table)
{
    $systemCatalogName = $this->quoteSystemCatalogName($table->catalogName);
    $databaseId = $this->getDatabaseIdExpression($table);
    $sql = <<<SQL
    SELECT
        [fk].[name] AS [fk_name],
        [cp].[name] AS [fk_column_name],
        OBJECT_NAME([fk].[referenced_object_id], {$databaseId}) AS [uq_table_name],
        [cr].[name] AS [uq_column_name]
    FROM
        {$systemCatalogName}.[foreign_keys] AS [fk]
        INNER JOIN {$systemCatalogName}.[foreign_key_columns] AS [fkc] ON
            [fk].[object_id] = [fkc].[constraint_object_id]
        INNER JOIN {$systemCatalogName}.[columns] AS [cp] ON
            [fk].[parent_object_id] = [cp].[object_id] AND
            [fkc].[parent_column_id] = [cp].[column_id]
        INNER JOIN {$systemCatalogName}.[columns] AS [cr] ON
            [fk].[referenced_object_id] = [cr].[object_id] AND
            [fkc].[referenced_column_id] = [cr].[column_id]
    WHERE
        [fk].[parent_object_id] = OBJECT_ID(:object)
    SQL;
    $rows = $this->db->createCommand(
        $sql,
        [':object' => $this->quoteTableFullName($table)],
    )->queryAll();
    $table->foreignKeys = [];
    foreach ($rows as $row) {
        if (!isset($table->foreignKeys[$row['fk_name']])) {
            $table->foreignKeys[$row['fk_name']][] = $row['uq_table_name'];
        }
        $table->foreignKeys[$row['fk_name']][$row['fk_column_name']] = $row['uq_column_name'];
    }
}

            

                protected function findPrimaryKeys($table)
{
    $result = [];
    foreach ($this->findTableConstraints($table, 'PK') as $row) {
        $result[] = $row['field_name'];
    }
    $table->primaryKey = $result;
}

            

                protected function findSchemaNames()
{
    $systemSchemaNames = "'"
        . implode("', '", array_map([Quoter::class, 'escapeLiteralValue'], $this->systemSchemaNames))
        . "'";
    $sql = <<<SQL
    SELECT [s].[name]
    FROM [sys].[schemas] AS [s]
    INNER JOIN [sys].[database_principals] AS [p] ON [p].[principal_id] = [s].[principal_id]
    WHERE [p].[is_fixed_role] = 0
        AND [p].[sid] IS NOT NULL
        AND [s].[name] NOT IN ({$systemSchemaNames})
    ORDER BY [s].[name] ASC
    SQL;
    return $this->db->createCommand(
        $sql,
    )->queryColumn();
}

            

                protected function findTableConstraints($table, $type)
{
    $systemCatalogName = $this->quoteSystemCatalogName($table->catalogName);
    $sql = <<<SQL
    SELECT
        [kc].[name] AS [index_name],
        [col].[name] AS [field_name]
    FROM {$systemCatalogName}.[key_constraints] AS [kc]
    INNER JOIN {$systemCatalogName}.[index_columns] AS [ic]
        ON [ic].[object_id] = [kc].[parent_object_id]
        AND [ic].[index_id] = [kc].[unique_index_id]
    INNER JOIN {$systemCatalogName}.[columns] AS [col]
        ON [col].[object_id] = [ic].[object_id]
        AND [col].[column_id] = [ic].[column_id]
    WHERE [kc].[parent_object_id] = OBJECT_ID(:fullName)
        AND [kc].[type] = :type
    ORDER BY [ic].[key_ordinal] ASC
    SQL;
    return $this->db->createCommand(
        $sql,
        [
            ':fullName' => $this->quoteTableFullName($table),
            ':type' => $type,
        ],
    )->queryAll();
}

            

                protected function findTableNames($schema = '')
{
    [$catalogName, $schemaName] = $this->resolveCatalogSchemaName($schema);
    $systemCatalogName = $this->quoteSystemCatalogName($catalogName);
    $sql = <<<SQL
    SELECT [o].[name]
    FROM {$systemCatalogName}.[objects] AS [o]
    INNER JOIN {$systemCatalogName}.[schemas] AS [s] ON [s].[schema_id] = [o].[schema_id]
    WHERE [s].[name] = :schema
        AND [o].[type] IN ('U', 'V')
    ORDER BY [o].[name]
    SQL;
    return $this->db->createCommand(
        $sql,
        [':schema' => $schemaName],
    )->queryColumn();
}

            

                public function findUniqueIndexes($table)
{
    $result = [];
    foreach ($this->findTableConstraints($table, 'UQ') as $row) {
        $result[$row['index_name']][] = $row['field_name'];
    }
    return $result;
}

            

                protected function findViewNames($schema = '')
{
    [$catalogName, $schemaName] = $this->resolveCatalogSchemaName($schema);
    $systemCatalogName = $this->quoteSystemCatalogName($catalogName);
    $sql = <<<SQL
    SELECT [v].[name]
    FROM {$systemCatalogName}.[views] AS [v]
    INNER JOIN {$systemCatalogName}.[schemas] AS [s] ON [s].[schema_id] = [v].[schema_id]
    WHERE [s].[name] = :schema
    ORDER BY [v].[name]
    SQL;
    return $this->db->createCommand(
        $sql,
        [':schema' => $schemaName],
    )->queryColumn();
}

            

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

            

                protected function getTableNameParts($name)
{
    preg_match_all('/([^.\[\]]+)|\[([^\[\]]+)\]/', $name, $matches);
    $parts = $matches[0] === [] ? [$name] : $matches[0];
    return str_replace(['[', ']'], '', $parts);
}

            

                public function insert($table, $columns)
{
    $command = $this->db->createCommand()->insert($table, $columns);
    if (!$command->execute()) {
        return false;
    }
    $inserted = $command->pdoStatement->fetch();
    $tableSchema = $this->getTableSchema($table);
    $result = [];
    foreach ($tableSchema->primaryKey as $name) {
        // @see https://github.com/yiisoft/yii2/issues/13828 & https://github.com/yiisoft/yii2/issues/17474
        if (isset($inserted[$name])) {
            $result[$name] = $inserted[$name];
        } elseif (isset($columns[$name])) {
            $result[$name] = $columns[$name];
        } else {
            $result[$name] = $tableSchema->columns[$name]->defaultValue;
        }
    }
    return $result;
}

            

                protected function loadColumnSchema($info)
{
    $column = $this->createColumnSchema();
    $column->name = $info['column_name'];
    $column->allowNull = $info['is_nullable'] === 'YES';
    $column->dbType = $info['data_type'];
    $column->enumValues = []; // MSSQL has only vague equivalents to enum.
    $column->isPrimaryKey = null; // Primary key will be determined in `findColumns()` method.
    $column->autoIncrement = (bool) $info['is_identity'];
    $column->isComputed = (bool) $info['is_computed'];
    $column->comment = $info['comment'] === null ? '' : $info['comment'];
    $column->type = self::TYPE_STRING;
    if (preg_match('/^(\w+)(?:\(([^\)]+)\))?/', $column->dbType, $matches)) {
        $type = $matches[1];
        if (isset($this->typeMap[$type])) {
            $column->type = $this->typeMap[$type];
        }
        if ($type === 'bit') {
            $column->type = self::TYPE_BOOLEAN;
        }
        if (!empty($matches[2]) && strcasecmp($matches[2], 'max') !== 0) {
            $values = explode(',', $matches[2]);
            $column->size = $column->precision = (int) $values[0];
            if (isset($values[1])) {
                $column->scale = (int) $values[1];
            }
        }
    }
    $column->phpType = $this->getColumnPhpType($column);
    // Store raw default for deferred resolution in `findColumns()`, where isPrimaryKey is known.
    $column->defaultValue = $info['column_default'];
    return $column;
}

            

                protected function loadTableChecks($tableName)
{
    return $this->loadTableConstraints($tableName, 'checks');
}

            

                protected function loadTableDefaultValues($tableName)
{
    return $this->loadTableConstraints($tableName, 'defaults');
}

            

                protected function loadTableForeignKeys($tableName)
{
    return $this->loadTableConstraints($tableName, 'foreignKeys');
}

            

                protected function loadTableIndexes($tableName)
{
    $resolvedName = $this->resolveTableName($tableName);
    $systemCatalogName = $this->quoteSystemCatalogName($resolvedName->catalogName);
    $sql = <<<SQL
    SELECT
        [i].[name] AS [name],
        [iccol].[name] AS [column_name],
        [i].[is_unique] AS [index_is_unique],
        [i].[is_primary_key] AS [index_is_primary]
    FROM {$systemCatalogName}.[indexes] AS [i]
    INNER JOIN {$systemCatalogName}.[index_columns] AS [ic]
        ON [ic].[object_id] = [i].[object_id] AND [ic].[index_id] = [i].[index_id]
    INNER JOIN {$systemCatalogName}.[columns] AS [iccol]
        ON [iccol].[object_id] = [ic].[object_id] AND [iccol].[column_id] = [ic].[column_id]
    WHERE [i].[object_id] = OBJECT_ID(:fullName)
    ORDER BY [ic].[key_ordinal] ASC
    SQL;
    $indexes = $this->db->createCommand(
        $sql,
        [':fullName' => $this->quoteTableFullName($resolvedName)],
    )->queryAll();
    $indexes = $this->normalizePdoRowKeyCase($indexes, true);
    $indexes = ArrayHelper::index($indexes, null, 'name');
    $result = [];
    foreach ($indexes as $name => $index) {
        $result[] = new IndexConstraint(
            [
                'isPrimary' => (bool) $index[0]['index_is_primary'],
                'isUnique' => (bool) $index[0]['index_is_unique'],
                'name' => $name,
                'columnNames' => ArrayHelper::getColumn($index, 'column_name'),
            ],
        );
    }
    return $result;
}

            

                protected function loadTablePrimaryKey($tableName)
{
    return $this->loadTableConstraints($tableName, 'primaryKey');
}

            

                protected function loadTableSchema($name)
{
    $table = $this->resolveTableName($name);
    $this->findPrimaryKeys($table);
    if ($this->findColumns($table)) {
        $this->findForeignKeys($table);
        return $table;
    }
    return null;
}

            

                protected function loadTableUniques($tableName)
{
    return $this->loadTableConstraints($tableName, 'uniques');
}

            

                public function quoteColumnName($name)
{
    if (Quoter::isIdentifierBracketQuoted($name)) {
        return $name;
    }
    return parent::quoteColumnName($name);
}

            

                public function quoteSystemCatalogName(string|null $catalogName): string
{
    return $this->quoteTableNameParts([$catalogName, 'sys']);
}

            

                public function quoteTableName($name)
{
    if (
        $this->defaultSchema !== 'dbo'
        && !str_starts_with($name, '(')
        && !str_contains($name, '{{')
        && !str_contains($name, '.')
    ) {
        $name = "{$this->defaultSchema}.$name";
    }
    return parent::quoteTableName($name);
}

            

                public function releaseSavepoint($name)
{
    // Does nothing as MSSQL does not support this.
}

            

                public function resolveRawCatalogSchemaName(string $schema): array
{
    return $this->resolveCatalogSchemaName($schema);
}

            

                protected function resolveTableName($name)
{
    $parts = $this->getTableNameParts($name);
    $partCount = count($parts);
    $last = $partCount - 1;
    $penultimate = $partCount - 2;
    $catalogIndex = $partCount === 4 ? 1 : 0;
    $tableName = $parts[$last];
    $schemaName = $partCount >= 2 ? $parts[$penultimate] : $this->defaultSchema;
    $catalogName = $partCount >= 3 ? $parts[$catalogIndex] : null;
    $fullName = match (true) {
        $catalogName !== null => "{$catalogName}.{$schemaName}.{$tableName}",
        $schemaName !== $this->defaultSchema => "{$schemaName}.{$tableName}",
        default => $tableName,
    };
    $resolvedName = new TableSchema();
    $resolvedName->name = $tableName;
    $resolvedName->schemaName = $schemaName;
    $resolvedName->catalogName = $catalogName;
    $resolvedName->fullName = $fullName;
    return $resolvedName;
}

            

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