Final Class Yiisoft\Db\Migration\MigrationBuilder

                public function __construct(
    private readonly ConnectionInterface $db,
    private readonly MigrationInformerInterface $informer,
    private readonly ?int $maxSqlOutputLength = null,
) {}

            

                public function addColumn(string $table, string $column, ColumnInterface|string $type): void
{
    if (is_string($type)) {
        $comment = null;
    } else {
        $comment = $type->getComment();
    }
    $typeAsString = $this->db->getQueryBuilder()->buildColumnDefinition($type);
    $time = $this->beginCommand("add column $column $typeAsString to table $table");
    $this->db->createCommand()->addColumn($table, $column, $type)->execute();
    if ($comment !== null) {
        $this->db->createCommand()->addCommentOnColumn($table, $column, $comment)->execute();
    }
    $this->endCommand($time);
}

            

                public function addCommentOnColumn(string $table, string $column, string $comment): void
{
    $time = $this->beginCommand("Add comment on column $column");
    $this->db->createCommand()->addCommentOnColumn($table, $column, $comment)->execute();
    $this->endCommand($time);
}

            

                public function addCommentOnTable(string $table, string $comment): void
{
    $time = $this->beginCommand("Add comment on table $table");
    $this->db->createCommand()->addCommentOnTable($table, $comment)->execute();
    $this->endCommand($time);
}

            

                public function addForeignKey(
    string $table,
    string $name,
    array|string $columns,
    string $referenceTable,
    array|string $referenceColumns,
    ?string $delete = null,
    ?string $update = null,
): void {
    $time = $this->beginCommand(
        "Add foreign key $name: $table (" . implode(',', (array) $columns) . ')'
        . " references $referenceTable (" . implode(',', (array) $referenceColumns) . ')',
    );
    $this->db->createCommand()->addForeignKey(
        $table,
        $name,
        $columns,
        $referenceTable,
        $referenceColumns,
        $delete,
        $update,
    )->execute();
    $this->endCommand($time);
}

            

                public function addPrimaryKey(string $table, string $name, array|string $columns): void
{
    $time = $this->beginCommand(
        "Add primary key $name on $table (" . implode(',', (array) $columns) . ')',
    );
    $this->db->createCommand()->addPrimaryKey($table, $name, $columns)->execute();
    $this->endCommand($time);
}

            

                public function alterColumn(string $table, string $column, ColumnInterface|string $type): void
{
    if (is_string($type)) {
        $comment = null;
    } else {
        $comment = $type->getComment();
    }
    $typeAsString = $this->db->getQueryBuilder()->buildColumnDefinition($type);
    $time = $this->beginCommand("Alter column $column in table $table to $typeAsString");
    $this->db->createCommand()->alterColumn($table, $column, $type)->execute();
    if ($comment !== null) {
        $this->db->createCommand()->addCommentOnColumn($table, $column, $comment)->execute();
    }
    $this->endCommand($time);
}

            

                public function batchInsert(string $table, array $columns, iterable $rows): void
{
    $time = $this->beginCommand("Insert into $table");
    $this->db->createCommand()->insertBatch($table, $rows, $columns)->execute();
    $this->endCommand($time);
}

            

                protected function beginCommand(string $description): float
{
    $this->informer->beginCommand($description);
    return microtime(true);
}

            

                public function columnBuilder(): string
{
    return $this->columnBuilderClass ??= $this->db->getColumnBuilderClass();
}

            

                public function createIndex(
    string $table,
    string $name,
    array|string $columns,
    ?string $indexType = null,
    ?string $indexMethod = null,
): void {
    $time = $this->beginCommand(
        'Create'
        . ($indexType !== null ? ' ' . $indexType : '')
        . " index $name on $table (" . implode(',', (array) $columns) . ')'
        . ($indexMethod !== null ? ' using ' . $indexMethod : ''),
    );
    $this->db->createCommand()->createIndex($table, $name, $columns, $indexType, $indexMethod)->execute();
    $this->endCommand($time);
}

            

                public function createTable(string $table, array $columns, ?string $options = null): void
{
    $time = $this->beginCommand("create table $table");
    $this->db->createCommand()->createTable($table, $columns, $options)->execute();
    foreach ($columns as $column => $type) {
        if ($type instanceof ColumnInterface) {
            $comment = $type->getComment();
            if ($comment !== null) {
                $this->db->createCommand()->addCommentOnColumn($table, $column, $comment)->execute();
            }
        }
    }
    $this->endCommand($time);
}

            

                public function createView(string $viewName, QueryInterface|string $subQuery): void
{
    $time = $this->beginCommand("Create view $viewName");
    $this->db->createCommand()->createView($viewName, $subQuery)->execute();
    $this->endCommand($time);
}

            

                public function delete(string $table, array|string $condition = '', array $params = []): void
{
    $time = $this->beginCommand("Delete from $table");
    $this->db->createCommand()->delete($table, $condition, $params)->execute();
    $this->endCommand($time);
}

            

                public function dropColumn(string $table, string $column): void
{
    $time = $this->beginCommand("drop column $column from table $table");
    $this->db->createCommand()->dropColumn($table, $column)->execute();
    $this->endCommand($time);
}

            

                public function dropCommentFromColumn(string $table, string $column): void
{
    $time = $this->beginCommand("Drop comment from column $column");
    $this->db->createCommand()->dropCommentFromColumn($table, $column)->execute();
    $this->endCommand($time);
}

            

                public function dropCommentFromTable(string $table): void
{
    $time = $this->beginCommand("drop comment from table $table");
    $this->db->createCommand()->dropCommentFromTable($table)->execute();
    $this->endCommand($time);
}

            

                public function dropForeignKey(string $table, string $name): void
{
    $time = $this->beginCommand("Drop foreign key $name from table $table");
    $this->db->createCommand()->dropForeignKey($table, $name)->execute();
    $this->endCommand($time);
}

            

                public function dropIndex(string $table, string $name): void
{
    if ($this->hasIndex($table, $name) === false) {
        $time = $this->beginCommand("Drop index $name on $table skipped. Index does not exist.");
        $this->endCommand($time);
        return;
    }
    $time = $this->beginCommand("Drop index $name on $table");
    $this->db->createCommand()->dropIndex($table, $name)->execute();
    $this->endCommand($time);
}

            

                public function dropPrimaryKey(string $table, string $name): void
{
    $time = $this->beginCommand("Drop primary key $name");
    $this->db->createCommand()->dropPrimaryKey($table, $name)->execute();
    $this->endCommand($time);
}

            

                public function dropTable(string $table): void
{
    $time = $this->beginCommand("Drop table $table");
    $this->db->createCommand()->dropTable($table)->execute();
    $this->endCommand($time);
}

            

                public function dropView(string $viewName): void
{
    $time = $this->beginCommand("Drop view $viewName");
    $this->db->createCommand()->dropView($viewName)->execute();
    $this->endCommand($time);
}

            

                protected function endCommand(float $time): void
{
    $this->informer->endCommand('Done in ' . sprintf('%.3f', microtime(true) - $time) . 's.');
}

            

                public function execute(string $sql, array $params = []): void
{
    $command = $this->db->createCommand($sql)->bindValues($params);
    $sqlOutput = trim($command->getRawSql());
    if ($this->maxSqlOutputLength !== null && $this->maxSqlOutputLength < strlen($sqlOutput)) {
        $sqlOutput = ltrim(rtrim(substr($sqlOutput, 0, $this->maxSqlOutputLength)) . ' [... hidden]');
    }
    $time = $this->beginCommand("Execute SQL: $sqlOutput");
    $command->execute();
    $this->endCommand($time);
}

            

                public function getDb(): ConnectionInterface
{
    return $this->db;
}

            

                public function insert(string $table, array $columns): void
{
    $time = $this->beginCommand("Insert into $table");
    $this->db->createCommand()->insert($table, $columns)->execute();
    $this->endCommand($time);
}

            

                public function renameColumn(string $table, string $name, string $newName): void
{
    $time = $this->beginCommand("Rename column $name in table $table to $newName");
    $this->db->createCommand()->renameColumn($table, $name, $newName)->execute();
    $this->endCommand($time);
}

            

                public function renameTable(string $table, string $newName): void
{
    $time = $this->beginCommand("rename table $table to $newName");
    $this->db->createCommand()->renameTable($table, $newName)->execute();
    $this->endCommand($time);
}

            

                public function truncateTable(string $table): void
{
    $time = $this->beginCommand("truncate table $table");
    $this->db->createCommand()->truncateTable($table)->execute();
    $this->endCommand($time);
}

            

                public function update(
    string $table,
    array $columns,
    array|ExpressionInterface|string $condition = '',
    array|ExpressionInterface|string|null $from = null,
    array $params = [],
): void {
    $time = $this->beginCommand("Update $table");
    $this->db->createCommand()->update($table, $columns, $condition, $from, $params)->execute();
    $this->endCommand($time);
}

            

                public function upsert(
    string $table,
    array|QueryInterface $insertColumns,
    array|bool $updateColumns = true,
): void {
    $time = $this->beginCommand("Upsert into $table");
    $this->db->createCommand()->upsert($table, $insertColumns, $updateColumns)->execute();
    $this->endCommand($time);
}