Vai al contenuto principale

API di Query Runner

Traduzione Beta Non Ufficiale

Questa pagina è stata tradotta da PageTurner AI (beta). Non ufficialmente approvata dal progetto. Hai trovato un errore? Segnala problema →

Per utilizzare un'API per modificare lo schema di un database, puoi usare QueryRunner.

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[]>

Restituisce tutti i nomi di database disponibili, inclusi i database di sistema.

getSchemas(database?: string): Promise<string[]>
  • database - Se viene specificato il parametro database, restituisce gli schemi di quel database

Restituisce tutti i nomi di schema disponibili, inclusi gli schemi di sistema. Utile solo per SQLServer e Postgres.

getTable(tableName: string): Promise<Table|undefined>
  • tableName - Nome della tabella da caricare

Carica una tabella dal database in base a un nome specificato.

getTables(tableNames: string[]): Promise<Table[]>
  • tableNames - Nomi delle tabelle da caricare

Carica le tabelle dal database in base ai nomi specificati.

hasDatabase(database: string): Promise<boolean>
  • database - Nome del database da verificare

Verifica se esiste un database con il nome specificato.

hasSchema(schema: string): Promise<boolean>
  • schema - Nome dello schema da verificare

Verifica se esiste uno schema con il nome specificato. Utilizzato solo per SqlServer e Postgres.

hasTable(table: Table|string): Promise<boolean>
  • table - Oggetto Table o nome

Verifica se la tabella esiste.

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

  • table - Oggetto Table o nome

  • columnName - Nome della colonna da verificare

Verifica se la colonna esiste nella tabella.

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

  • database - Nome del database

  • ifNotExist - Salta la creazione se true, altrimenti genera un errore se il database esiste già

Crea un nuovo database.

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

  • database - Nome del database

  • ifExist - Salta l'eliminazione se true, altrimenti genera un errore se il database non viene trovato

Elimina il database.

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

  • schemaPath - Nome dello schema. Per SqlServer accetta percorsi di schema (es. 'dbName.schemaName'). Se passato un percorso, creerà lo schema nel database specificato

  • ifNotExist - Salta la creazione se true, altrimenti genera un errore se lo schema esiste già

Crea un nuovo schema di tabella.

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

  • schemaPath - Nome dello schema. Per SqlServer accetta percorsi di schema (es. 'dbName.schemaName'). Se passato un percorso, eliminerà lo schema nel database specificato

  • ifExist - Salta l'eliminazione se true, altrimenti genera un errore se lo schema non viene trovato

  • isCascade - Se true, elimina automaticamente gli oggetti (tabelle, funzioni, ecc.) contenuti nello schema. Utilizzato solo in Postgres

Elimina uno schema di tabella.

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

  • table - Oggetto Tabella

  • ifNotExist - Salta la creazione se true, altrimenti genera un errore se la tabella esiste già. Predefinito false

  • createForeignKeys - Indica se creare chiavi esterne durante la creazione della tabella. Predefinito true

  • createIndices - Indica se creare indici durante la creazione della tabella. Predefinito true

Crea una nuova tabella.

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

  • table - Oggetto Tabella o nome della tabella da eliminare

  • ifExist - Salta l'eliminazione se true, altrimenti genera un errore se la tabella non esiste

  • dropForeignKeys - Indica se eliminare le chiavi esterne durante la cancellazione della tabella. Predefinito true

  • dropIndices - Indica se eliminare gli indici durante la cancellazione della tabella. Predefinito true

Elimina una tabella.

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

  • oldTableOrName - Vecchio oggetto Tabella o nome da rinominare

  • newTableName - Nuovo nome della tabella

Rinomina una tabella.

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

  • table - Oggetto Table o nome

  • column - Nuova colonna

Aggiunge nuove colonne.

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

  • table - Oggetto Table o nome

  • columns - Nuove colonne

Aggiunge nuove colonne.

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

  • table - Oggetto Table o nome

  • oldColumnOrName - Vecchia colonna. Accetta un oggetto TableColumn o il nome della colonna

  • newColumnOrName - Nuova colonna. Accetta un oggetto TableColumn o il nome della colonna

Rinomina una colonna.

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

  • table - Oggetto Table o nome

  • oldColumn - Vecchia colonna. Accetta un oggetto TableColumn o il nome della colonna

  • newColumn - Nuova colonna. Accetta un oggetto TableColumn

Modifica una colonna nella tabella.

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

  • table - Oggetto Table o nome

  • changedColumns - Array di colonne modificate:

    • oldColumn - Vecchio oggetto TableColumn
    • newColumn - Nuovo oggetto TableColumn

Modifica più colonne nella tabella.

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

  • table - Oggetto Table o nome

  • column - Oggetto TableColumn o nome della colonna da eliminare

Elimina una colonna nella tabella.

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

  • table - Oggetto Table o nome

  • columns - array di oggetti TableColumn o nomi di colonne da eliminare

Elimina più colonne nella tabella.

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

  • table - Oggetto Table o nome

  • columnNames - array di nomi di colonne che costituiranno la chiave primaria

Crea una nuova chiave primaria.

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

  • table - Oggetto Table o nome

  • columns - array di oggetti TableColumn da aggiornare

Aggiorna chiavi primarie composite.

dropPrimaryKey(table: Table|string): Promise<void>
  • table - Oggetto Table o nome

Elimina una chiave primaria.

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

  • table - Oggetto Table o nome

  • uniqueConstraint - Oggetto TableUnique da creare

Crea un nuovo vincolo di unicità.

Nota: non funziona per MySQL, poiché MySQL memorizza i vincoli di unicità come indici univoci. Usare invece il metodo createIndex().

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

  • table - Oggetto Table o nome

  • uniqueConstraints - array di oggetti TableUnique da creare

Crea nuovi vincoli di unicità.

Nota: non funziona per MySQL, poiché MySQL memorizza i vincoli di unicità come indici univoci. Usare invece il metodo createIndices().

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

  • table - Oggetto Table o nome

  • uniqueOrName - Oggetto TableUnique o nome del vincolo di unicità da eliminare

Elimina un vincolo di unicità.

Nota: non funziona per MySQL, poiché MySQL memorizza i vincoli di unicità come indici univoci. Usare invece il metodo dropIndex().

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

  • table - Oggetto Table o nome

  • uniqueConstraints - array di oggetti TableUnique da eliminare

Elimina più vincoli di unicità.

Nota: non funziona per MySQL, perché MySQL memorizza i vincoli univoci come indici univoci. Utilizza invece il metodo dropIndices().

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

  • table - Oggetto Table o nome

  • checkConstraint - Oggetto TableCheck

Crea nuovi vincoli di controllo.

Nota: MySQL non supporta i vincoli di controllo.

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

  • table - Oggetto Table o nome

  • checkConstraints - array di oggetti TableCheck

Crea nuovi vincoli di controllo.

Nota: MySQL non supporta i vincoli di controllo.

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

  • table - Oggetto Table o nome

  • checkOrName - Oggetto TableCheck o nome del vincolo di controllo

Elimina un vincolo di controllo.

Nota: MySQL non supporta i vincoli di controllo.

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

  • table - Oggetto Table o nome

  • checkConstraints - array di oggetti TableCheck

Elimina più vincoli di controllo.

Nota: MySQL non supporta i vincoli di controllo.

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

  • table - Oggetto Table o nome

  • foreignKey - Oggetto TableForeignKey

Crea una nuova chiave esterna (foreign key).

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

  • table - Oggetto Table o nome

  • foreignKeys - array di oggetti TableForeignKey

Crea nuove chiavi esterne.

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

  • table - Oggetto Table o nome

  • foreignKeyOrName - Oggetto TableForeignKey o nome della chiave esterna

Elimina una chiave esterna.

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

  • table - Oggetto Table o nome

  • foreignKeys - array di oggetti TableForeignKey

Elimina più chiavi esterne.

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

  • table - Oggetto Table o nome

  • index - Oggetto TableIndex

Crea un nuovo indice.

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

  • table - Oggetto Table o nome

  • indices - array di oggetti TableIndex

Crea nuovi indici.

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

  • table - Oggetto Table o nome

  • index - Oggetto TableIndex o nome dell'indice

Elimina un indice.

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

  • table - Oggetto Table o nome

  • indices - array di oggetti TableIndex

Elimina più indici.

clearTable(tableName: string): Promise<void>
  • tableName - nome della tabella

Svuota tutti i contenuti della tabella.

Nota: questa operazione utilizza la query TRUNCATE di SQL che non può essere annullata nelle transazioni.

enableSqlMemory(): void

Attiva la modalità speciale del query runner in cui le query SQL non vengono eseguite, ma memorizzate in una variabile speciale all'interno del query runner. È possibile recuperare le query memorizzate utilizzando il metodo getMemorySql().

disableSqlMemory(): void

Disattiva la modalità speciale del query runner in cui le query SQL non vengono eseguite. Le query precedentemente memorizzate verranno eliminate.

clearSqlMemory(): void

Svuota tutte le query SQL memorizzate.

getMemorySql(): SqlInMemory
  • restituisce un oggetto SqlInMemory con array di query SQL upQueries e downQueries

Recupera le query SQL memorizzate. I parametri nelle query sono già sostituiti.

executeMemoryUpSql(): Promise<void>

Esegue le query SQL di tipo "up" memorizzate.

executeMemoryDownSql(): Promise<void>

Esegue le query SQL di tipo "down" memorizzate.