查询运行器 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")
    }
}

查询运行器 API

getDatabases(): Promise<string[]>

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

查询运行器 API

getSchemas(database?: string): Promise<string[]>

• database - 若指定该参数，则返回该数据库的模式

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

查询运行器 API

getTable(tableName: string): Promise<Table|undefined>

• tableName - 待加载表的名称

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

查询运行器 API

getTables(tableNames: string[]): Promise<Table[]>

• tableNames - 待加载表的名称列表

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

查询运行器 API

hasDatabase(database: string): Promise<boolean>

• database - 待检查的数据库名称

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

查询运行器 API

hasSchema(schema: string): Promise<boolean>

• schema - 待检查的模式名称

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

查询运行器 API

hasTable(table: Table|string): Promise<boolean>

• table - Table 对象或表名

检查表是否存在

查询运行器 API

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

• table - Table 对象或表名

• columnName - 待检查的列名称

检查表中是否存在指定列

查询运行器 API

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

• database - 数据库名称

• ifNotExists - 若设为 true，当数据库已存在时静默忽略；否则抛出错误（默认）

创建新数据库

查询运行器 API

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

• database - 数据库名称

• ifExists - 若设为 true，当数据库不存在时静默忽略；否则抛出错误（默认）

删除数据库

查询运行器 API

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

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

• ifNotExists - 若设为 true，当模式已存在时静默忽略；否则抛出错误（默认）

创建新表模式

查询运行器 API

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

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

• ifExists - 若设为 true，当模式不存在时静默忽略；否则抛出错误（默认）

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

删除表模式

查询运行器 API

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

• table - 表对象

• ifNotExists - 若设为 true，当表已存在时静默忽略；否则抛出错误（默认）

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

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

创建新表

查询运行器 API

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

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

• ifExists - 若设为 true，当表不存在时静默忽略；否则抛出错误（默认）

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

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

删除表

查询运行器 API

createView(view: View, syncWithMetadata?: boolean, oldView?: View): Promise<void>

• view - View 对象

• syncWithMetadata - 是否与元数据同步视图（可选）

• oldView - 待替换的原 View 对象（可选）

创建新视图

查询运行器 API

dropView(view: View|string, ifExists?: boolean): Promise<void>

• view - 待删除的 View 对象或视图名称

• ifExists - 若设为 true，当视图不存在时静默忽略；否则抛出错误（默认）

删除视图

查询运行器 API

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

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

• newTableName - 新表名称

重命名表。

查询运行器 API

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

• table - Table 对象或表名

• column - 新列定义

添加多个新列。

查询运行器 API

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

• table - Table 对象或表名

• columns - 新列定义数组

添加多个新列。

查询运行器 API

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

• table - Table 对象或表名

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

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

重命名列。

查询运行器 API

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

• table - Table 对象或表名

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

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

修改表中的列定义。

查询运行器 API

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

• table - Table 对象或表名

• changedColumns - 变更列数组：

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

批量修改表中的列定义。

查询运行器 API

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

• table - Table 对象或表名

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

• ifExists - 若设为 true，当列不存在时静默忽略；否则抛出错误（默认）

删除表中的列。

查询运行器 API

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

• table - Table 对象或表名

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

• ifExists - 若设为 true，当列不存在时静默忽略；否则抛出错误（默认）

批量删除表中的列

查询运行器 API

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

• table - Table 对象或表名

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

创建主键约束。

查询运行器 API

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

• table - Table 对象或表名

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

更新复合主键约束。

查询运行器 API

dropPrimaryKey(table: Table|string, constraintName?: string, ifExists?: boolean): Promise<void>

• table - Table 对象或表名

• constraintName - 约束名称（可选）

• ifExists - 若设为 true，当主键不存在时静默忽略；否则抛出错误（默认）

删除主键约束。

查询运行器 API

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

• table - Table 对象或表名

• uniqueConstraint - 待创建的 TableUnique 对象

创建唯一约束。

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

查询运行器 API

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

• table - Table 对象或表名

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

批量创建唯一约束。

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

查询运行器 API

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

• table - Table 对象或表名

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

• ifExists - 若设为 true，当约束不存在时静默忽略；否则抛出错误（默认）

删除唯一约束

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

查询运行器 API

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

• table - Table 对象或表名

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

• ifExists - 若设为 true，当约束不存在时静默忽略；否则抛出错误（默认）

删除唯一约束

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

查询运行器 API

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

• table - Table 对象或表名

• checkConstraint - TableCheck 对象

创建新的检查约束

注意：MySQL 不支持检查约束

查询运行器 API

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

• table - Table 对象或表名

• checkConstraints - TableCheck 对象数组

创建新的检查约束

注意：MySQL 不支持检查约束

查询运行器 API

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

• table - Table 对象或表名

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

• ifExists - 若设为 true，当约束不存在时静默忽略；否则抛出错误（默认）

删除检查约束

注意：MySQL 不支持检查约束

查询运行器 API

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

• table - Table 对象或表名

• checkConstraints - TableCheck 对象数组

• ifExists - 若设为 true，当约束不存在时静默忽略；否则抛出错误（默认）

删除多个检查约束。

注意：MySQL 不支持检查约束

查询运行器 API

createExclusionConstraint(table: Table|string, exclusionConstraint: TableExclusion): Promise<void>

• table - Table 对象或表名

• exclusionConstraint - TableExclusion 对象

创建排除约束

注意：仅 PostgreSQL 支持排除约束

查询运行器 API

createExclusionConstraints(table: Table|string, exclusionConstraints: TableExclusion[]): Promise<void>

• table - Table 对象或表名

• exclusionConstraints - TableExclusion 对象数组

批量创建排除约束

注意：仅 PostgreSQL 支持排除约束

查询运行器 API

dropExclusionConstraint(table: Table|string, exclusionOrName: TableExclusion|string, ifExists?: boolean): Promise<void>

• table - Table 对象或表名

• exclusionOrName - TableExclusion 对象或排除约束名称

• ifExists - 若设为 true，当约束不存在时静默忽略；否则抛出错误（默认）

删除排除约束

注意：仅 PostgreSQL 支持排除约束

查询运行器 API

dropExclusionConstraints(table: Table|string, exclusionConstraints: TableExclusion[], ifExists?: boolean): Promise<void>

• table - Table 对象或表名

• exclusionConstraints - TableExclusion 对象数组

• ifExists - 若设为 true，当约束不存在时静默忽略；否则抛出错误（默认）

批量删除排除约束

注意：仅 PostgreSQL 支持排除约束

查询运行器 API

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

• table - Table 对象或表名

• foreignKey - TableForeignKey 对象

创建外键。

查询运行器 API

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

• table - Table 对象或表名

• foreignKeys - TableForeignKey 对象数组

创建多个外键。

查询运行器 API

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

• table - Table 对象或表名

• foreignKeyOrName - TableForeignKey 对象或外键名称

• ifExists - 若设为 true，当外键不存在时静默忽略；否则抛出错误（默认）

删除外键。

查询运行器 API

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

• table - Table 对象或表名

• foreignKeys - TableForeignKey 对象数组

• ifExists - 若设为 true，当外键不存在时静默忽略，否则抛出错误（默认行为）

删除外键。

查询运行器 API

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

• table - Table 对象或表名

• index - TableIndex 对象

创建索引。

查询运行器 API

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

• table - Table 对象或表名

• indices - TableIndex 对象数组

创建多个索引。

查询运行器 API

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

• table - Table 对象或表名

• index - TableIndex 对象或索引名称

• ifExists - 若设为 true，当索引不存在时静默忽略，否则抛出错误（默认行为）

删除索引。

查询运行器 API

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

• table - Table 对象或表名

• indices - TableIndex 对象数组

• ifExists - 若设为 true，当索引不存在时静默忽略，否则抛出错误（默认行为）

删除索引。

查询运行器 API

clearTable(tableName: string, options?: {cascade?: boolean}): Promise<void>

• tableName - 表名

• options - 附加选项

  • cascade - 是否级联清除含外键关联的表数据（仅 PostgreSQL/CockroachDB 和 Oracle 支持；其他数据库若设为 true 将抛出错误），默认为 false

清除表中所有数据内容。

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

查询运行器 API

enableSqlMemory(): void

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

查询运行器 API

disableSqlMemory(): void

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

查询运行器 API

clearSqlMemory(): void

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

查询运行器 API

getMemorySql(): SqlInMemory

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

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

查询运行器 API

executeMemoryUpSql(): Promise<void>

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

查询运行器 API

executeMemoryDownSql(): Promise<void>

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

查询运行器 API