跳至主内容区

查询运行器 API

非官方测试版翻译

本页面由 PageTurner AI 翻译（测试版）。未经项目官方认可。 发现错误？ 报告问题 →

通过 QueryRunner API 可实现编程式数据库结构变更：

import {
    MigrationInterface,
    QueryRunner,
    Table,
    TableIndex,
    TableColumn,
    TableForeignKey,
} from "typeorm"

export class QuestionRefactoringTIMESTAMP implements MigrationInterface {
    async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.createTable(
            new Table({
                name: "question",
                columns: [
                    {
                        name: "id",
                        type: "int",
                        isPrimary: true,
                    },
                    {
                        name: "name",
                        type: "varchar",
                    },
                ],
            }),
            true,
        )

        await queryRunner.createIndex(
            "question",
            new TableIndex({
                name: "IDX_QUESTION_NAME",
                columnNames: ["name"],
            }),
        )

        await queryRunner.createTable(
            new Table({
                name: "answer",
                columns: [
                    {
                        name: "id",
                        type: "int",
                        isPrimary: true,
                    },
                    {
                        name: "name",
                        type: "varchar",
                    },
                    {
                        name: "created_at",
                        type: "timestamp",
                        default: "now()",
                    },
                ],
            }),
            true,
        )

        await queryRunner.addColumn(
            "answer",
            new TableColumn({
                name: "questionId",
                type: "int",
            }),
        )

        await queryRunner.createForeignKey(
            "answer",
            new TableForeignKey({
                columnNames: ["questionId"],
                referencedColumnNames: ["id"],
                referencedTableName: "question",
                onDelete: "CASCADE",
            }),
        )
    }

    async down(queryRunner: QueryRunner): Promise<void> {
        const table = await queryRunner.getTable("answer")
        const foreignKey = table.foreignKeys.find(
            (fk) => fk.columnNames.indexOf("questionId") !== -1,
        )
        await queryRunner.dropForeignKey("answer", foreignKey)
        await queryRunner.dropColumn("answer", "questionId")
        await queryRunner.dropTable("answer")
        await queryRunner.dropIndex("question", "IDX_QUESTION_NAME")
        await queryRunner.dropTable("question")
    }
}
getDatabases(): Promise<string[]>

返回所有可用数据库名称（含系统数据库）

getSchemas(database?: string): Promise<string[]>
  • database - 若指定该参数，则返回该数据库的模式

返回所有可用模式名称（含系统模式），仅适用于 SQLServer 和 Postgres

getTable(tableName: string): Promise<Table|undefined>
  • tableName - 待加载表的名称

根据指定名称从数据库加载表

getTables(tableNames: string[]): Promise<Table[]>
  • tableNames - 待加载表的名称列表

根据指定名称列表从数据库加载多个表

hasDatabase(database: string): Promise<boolean>
  • database - 待检查的数据库名称

检查指定名称的数据库是否存在

hasSchema(schema: string): Promise<boolean>
  • schema - 待检查的模式名称

检查指定名称的模式是否存在（仅适用于 SqlServer 和 Postgres）

hasTable(table: Table|string): Promise<boolean>
  • table - Table 对象或表名

检查表是否存在

hasColumn(table: Table|string, columnName: string): Promise<boolean>

  • table - Table 对象或表名

  • columnName - 待检查的列名称

检查表中是否存在指定列

createDatabase(database: string, ifNotExist?: boolean): Promise<void>

  • database - 数据库名称

  • ifNotExist - 若为 true 则跳过创建（当数据库已存在时不报错）

创建新数据库

dropDatabase(database: string, ifExist?: boolean): Promise<void>

  • database - 数据库名称

  • ifExist - 若为 true 则跳过删除（当数据库不存在时不报错）

删除数据库

createSchema(schemaPath: string, ifNotExist?: boolean): Promise<void>

  • schemaPath - 模式名称。对于 SqlServer 可接受模式路径（如 'dbName.schemaName'），若传递路径参数则会在指定数据库创建模式

  • ifNotExist - 若为 true 则跳过创建（当模式已存在时不报错）

创建新表模式

dropSchema(schemaPath: string, ifExist?: boolean, isCascade?: boolean): Promise<void>

  • schemaPath - 模式名称。对于 SqlServer 可接受模式路径（如 'dbName.schemaName'），若传递路径参数则会在指定数据库删除模式

  • ifExist - 若为 true 则跳过删除（当模式不存在时不报错）

  • isCascade - 若为 true 则级联删除模式内对象（表、函数等），仅适用于 Postgres

删除表模式

createTable(table: Table, ifNotExist?: boolean, createForeignKeys?: boolean, createIndices?: boolean): Promise<void>

  • table - 表对象

  • ifNotExist - 若为 true 则跳过创建（当表已存在时不报错），默认 false

  • createForeignKeys - 是否在创建表时同步创建外键，默认 true

  • createIndices - 是否在创建表时同步创建索引，默认 true

创建新表

dropTable(table: Table|string, ifExist?: boolean, dropForeignKeys?: boolean, dropIndices?: boolean): Promise<void>

  • table - 待删除的表对象或表名称

  • ifExist - 若为 true 则跳过删除（当表不存在时不报错）

  • dropForeignKeys - 是否在删除表时同步删除外键，默认 true

  • dropIndices - 是否在删除表时同步删除索引，默认 true

删除表

renameTable(oldTableOrName: Table|string, newTableName: string): Promise<void>

  • oldTableOrName - 待重命名的原表对象或表名称

  • newTableName - 新表名称

重命名表。

addColumn(table: Table|string, column: TableColumn): Promise<void>

  • table - Table 对象或表名

  • column - 新列定义

添加多个新列。

addColumns(table: Table|string, columns: TableColumn[]): Promise<void>

  • table - Table 对象或表名

  • columns - 新列定义数组

添加多个新列。

renameColumn(table: Table|string, oldColumnOrName: TableColumn|string, newColumnOrName: TableColumn|string): Promise<void>

  • table - Table 对象或表名

  • oldColumnOrName - 原列（可接受 TableColumn 对象或列名称）

  • newColumnOrName - 新列（可接受 TableColumn 对象或列名称）

重命名列。

changeColumn(table: Table|string, oldColumn: TableColumn|string, newColumn: TableColumn): Promise<void>

  • table - Table 对象或表名

  • oldColumn - 原列（可接受 TableColumn 对象或列名称）

  • newColumn - 新列（可接受 TableColumn 对象）

修改表中的列定义。

changeColumns(table: Table|string, changedColumns: { oldColumn: TableColumn, newColumn: TableColumn }[]): Promise<void>

  • table - Table 对象或表名

  • changedColumns - 变更列数组：

    • oldColumn - 原 TableColumn 对象
    • newColumn - 新 TableColumn 对象

批量修改表中的列定义。

dropColumn(table: Table|string, column: TableColumn|string): Promise<void>

  • table - Table 对象或表名

  • column - 待删除的 TableColumn 对象或列名

删除表中的列。

dropColumns(table: Table|string, columns: TableColumn[]|string[]): Promise<void>

  • table - Table 对象或表名

  • columns - 待删除的 TableColumn 对象或列名数组

批量删除表中的列。

createPrimaryKey(table: Table|string, columnNames: string[]): Promise<void>

  • table - Table 对象或表名

  • columnNames - 将作为主键的列名数组

创建主键约束。

updatePrimaryKeys(table: Table|string, columns: TableColumn[]): Promise<void>

  • table - Table 对象或表名

  • columns - 待更新的 TableColumn 对象数组

更新复合主键约束。

dropPrimaryKey(table: Table|string): Promise<void>
  • table - Table 对象或表名

删除主键约束。

createUniqueConstraint(table: Table|string, uniqueConstraint: TableUnique): Promise<void>

  • table - Table 对象或表名

  • uniqueConstraint - 待创建的 TableUnique 对象

创建唯一约束。

注意：MySQL不支持此操作，因为MySQL将唯一约束存储为唯一索引，请改用createIndex()方法

createUniqueConstraints(table: Table|string, uniqueConstraints: TableUnique[]): Promise<void>

  • table - Table 对象或表名

  • uniqueConstraints - 待创建的 TableUnique 对象数组

批量创建唯一约束。

注意：MySQL不支持此操作，因为MySQL将唯一约束存储为唯一索引，请改用createIndices()方法

dropUniqueConstraint(table: Table|string, uniqueOrName: TableUnique|string): Promise<void>

  • table - Table 对象或表名

  • uniqueOrName - 待删除的 TableUnique 对象或唯一约束名称

删除唯一约束

注意：MySQL 不适用此方法，因为 MySQL 将唯一约束存储为唯一索引。请改用 dropIndex() 方法。

dropUniqueConstraints(table: Table|string, uniqueConstraints: TableUnique[]): Promise<void>

  • table - Table 对象或表名

  • uniqueConstraints - 待删除的 TableUnique 对象数组

删除唯一约束

注意：MySQL 不适用此方法，因为 MySQL 将唯一约束存储为唯一索引。请改用 dropIndices() 方法。

createCheckConstraint(table: Table|string, checkConstraint: TableCheck): Promise<void>

  • table - Table 对象或表名

  • checkConstraint - TableCheck 对象

创建新的检查约束

注意：MySQL 不支持检查约束

createCheckConstraints(table: Table|string, checkConstraints: TableCheck[]): Promise<void>

  • table - Table 对象或表名

  • checkConstraints - TableCheck 对象数组

创建新的检查约束

注意：MySQL 不支持检查约束

dropCheckConstraint(table: Table|string, checkOrName: TableCheck|string): Promise<void>

  • table - Table 对象或表名

  • checkOrName - TableCheck 对象或检查约束名称

删除检查约束。

注意：MySQL 不支持检查约束

dropCheckConstraints(table: Table|string, checkConstraints: TableCheck[]): Promise<void>

  • table - Table 对象或表名

  • checkConstraints - TableCheck 对象数组

删除多个检查约束。

注意：MySQL 不支持检查约束

createForeignKey(table: Table|string, foreignKey: TableForeignKey): Promise<void>

  • table - Table 对象或表名

  • foreignKey - TableForeignKey 对象

创建外键。

createForeignKeys(table: Table|string, foreignKeys: TableForeignKey[]): Promise<void>

  • table - Table 对象或表名

  • foreignKeys - TableForeignKey 对象数组

创建多个外键。

dropForeignKey(table: Table|string, foreignKeyOrName: TableForeignKey|string): Promise<void>

  • table - Table 对象或表名

  • foreignKeyOrName - TableForeignKey 对象或外键名称

删除外键。

dropForeignKeys(table: Table|string, foreignKeys: TableForeignKey[]): Promise<void>

  • table - Table 对象或表名

  • foreignKeys - TableForeignKey 对象数组

删除多个外键。

createIndex(table: Table|string, index: TableIndex): Promise<void>

  • table - Table 对象或表名

  • index - TableIndex 对象

创建索引。

createIndices(table: Table|string, indices: TableIndex[]): Promise<void>

  • table - Table 对象或表名

  • indices - TableIndex 对象数组

创建多个索引。

dropIndex(table: Table|string, index: TableIndex|string): Promise<void>

  • table - Table 对象或表名

  • index - TableIndex 对象或索引名称

删除索引。

dropIndices(table: Table|string, indices: TableIndex[]): Promise<void>

  • table - Table 对象或表名

  • indices - TableIndex 对象数组

删除多个索引。

clearTable(tableName: string): Promise<void>
  • tableName - 表名

清除表中所有数据内容。

注意：该操作使用 SQL 的 TRUNCATE 查询，在事务中无法回滚。

enableSqlMemory(): void

启用特殊查询运行器模式：SQL 查询将不会实际执行，而是被记录到查询运行器的内存变量中。 可通过 getMemorySql() 方法获取已记录的 SQL 语句。

disableSqlMemory(): void

禁用特殊查询运行器模式。之前记录的所有 SQL 语句将被清空。

clearSqlMemory(): void

清空所有已记录的 SQL 语句。

getMemorySql(): SqlInMemory
  • 返回包含 upQueries 和 downQueries SQL 语句数组的 SqlInMemory 对象

获取内存中存储的 SQL 语句（参数已被实际值替换）。

executeMemoryUpSql(): Promise<void>

执行内存中记录的升级 SQL 查询。

executeMemoryDownSql(): Promise<void>

执行内存中记录的降级 SQL 查询。