# Django 6.0.5 documentation

# `SchemaEditor`

class BaseDatabaseSchemaEditor

Djangos migreringssystem är uppdelat i två delar; logiken för att beräkna och lagra vilka operationer som ska köras (`django.db.migrations`), och databasabstraktionslagret som omvandlar saker som ”skapa en modell” eller ”ta bort ett fält” till SQL - vilket är jobbet för `SchemaEditor`.

Det är osannolikt att du kommer att vilja interagera direkt med `SchemaEditor` som en vanlig utvecklare som använder Django, men om du vill skriva ditt eget migrationssystem eller har mer avancerade behov är det mycket trevligare än att skriva SQL.

Varje databasbackend i Django tillhandahåller sin egen version av `SchemaEditor`, och den är alltid tillgänglig via kontexthanteraren `connection.schema_editor()`:

    with connection.schema_editor() as schema_editor:
        schema_editor.delete_model(MyModel)

Den måste användas via kontexthanteraren eftersom den då kan hantera saker som transaktioner och uppskjuten SQL (som att skapa `ForeignKey`-begränsningar).

Den exponerar alla möjliga operationer som metoder, som ska anropas i den ordning du vill att ändringarna ska tillämpas. Vissa möjliga operationer eller typer av ändringar är inte möjliga i alla databaser - MyISAM stöder t.ex. inte begränsningar för främmande nycklar.

Om du skriver eller underhåller en tredjeparts databasbackend för Django måste du tillhandahålla en `SchemaEditor`-implementering för att kunna arbeta med Djangos migreringsfunktionalitet - men så länge din databas är relativt standard i sin användning av SQL och relationsdesign bör du kunna underordna en av de inbyggda Django `SchemaEditor`-klasserna och justera syntaxen lite.

## Metoder

### `execute()`

BaseDatabaseSchemaEditor.execute(sql, params=())

Exekverar den SQL-sats som skickas in, med eventuella parametrar. Detta är ett omslag runt de normala databasmarkörerna som gör det möjligt att fånga SQL till en `.sql`-fil om användaren så önskar.

### `create_model()`

BaseDatabaseSchemaEditor.create_model(model)

Skapar en ny tabell i databasen för den angivna modellen, tillsammans med eventuella unika begränsningar eller index som krävs.

### `delete_model()`

BaseDatabaseSchemaEditor.delete_model(model)

Tar bort modellens tabell i databasen tillsammans med alla unika begränsningar eller index som den har.

### `add_index()`

BaseDatabaseSchemaEditor.add_index(model, index)

Lägger till `index` till `model`’s tabell.

### `remove_index()`

BaseDatabaseSchemaEditor.remove_index(model, index)

Tar bort `index` från `modell`:s tabell.

### `rename_index()`

BaseDatabaseSchemaEditor.rename_index(model, old_index, new_index)

Byter namn på `old_index` från `model`’s tabell till `new_index`.

### `add_constraint()`

BaseDatabaseSchemaEditor.add_constraint(model, constraint)

Lägger till `constraint` till `model`’s tabell.

### `remove_constraint()`

BaseDatabaseSchemaEditor.remove_constraint(model, constraint)

Tar bort `constraint` från `model`’s tabell.

### `alter_unique_together()`

BaseDatabaseSchemaEditor.alter_unique_together(model, old_unique_together, new_unique_together)

Ändrar en modells `unique_together`-värde; detta kommer att lägga till eller ta bort unika begränsningar från modellens tabell tills de matchar det nya värdet.

### `alter_index_together()`

BaseDatabaseSchemaEditor.alter_index_together(model, old_index_together, new_index_together)

Ändrar en modells `index_together`-värde; detta kommer att lägga till eller ta bort index från modellens tabell tills de matchar det nya värdet.

### `alter_db_table()`

BaseDatabaseSchemaEditor.alter_db_table(model, old_db_table, new_db_table)

Byter namn på modellens tabell från `old_db_table` till `new_db_table`.

### `alter_db_table_comment()`

BaseDatabaseSchemaEditor.alter_db_table_comment(model, old_db_table_comment, new_db_table_comment)

Ändra tabellkommentaren för `model` till `new_db_table_comment`.

### `alter_db_tablespace()`

BaseDatabaseSchemaEditor.alter_db_tablespace(model, old_db_tablespace, new_db_tablespace)

Flyttar modellens tabell från ett tablespace till ett annat.

### `add_field()`

BaseDatabaseSchemaEditor.add_field(model, field)

Lägger till en kolumn (eller ibland flera) i modellens tabell för att representera fältet. Detta kommer också att lägga till index eller en unik begränsning om fältet har `db_index=True` eller `unique=True`.

Om fältet är ett `ManyToManyField` utan ett värde för `through` skapas en tabell för att representera relationen istället för en kolumn. Om `through` anges är det ett no-op.

Om fältet är en `ForeignKey` läggs även begränsningen för främmande nyckel till i kolumnen.

### `remove_field()`

BaseDatabaseSchemaEditor.remove_field(model, field)

Tar bort den eller de kolumner som representerar fältet från modellens tabell, tillsammans med eventuella unika begränsningar, begränsningar för främmande nycklar eller index som orsakas av fältet.

Om fältet är ett ManyToMany-fält utan ett värde för `through` tas den tabell bort som skapats för att spåra relationen. Om `through` anges är det ett no-op.

### `Ändra_fält()`

BaseDatabaseSchemaEditor.alter_field(model, old_field, new_field, strict=False)

Detta omvandlar fältet i modellen från det gamla fältet till det nya. Detta inkluderar ändring av kolumnens namn (attributet `db_column`), ändring av fältets typ (om fältklassen ändras), ändring av fältets `NULL`-status, tillägg eller borttagning av unika begränsningar och index för enbart fält, ändring av primärnyckel och ändring av destinationen för `ForeignKey`-begränsningar.

Den vanligaste transformationen som detta inte kan göra är att omvandla ett `ManyToManyField` till ett vanligt fält eller vice versa; Django kan inte göra detta utan att förlora data, och därför kommer det att vägra att göra det. Istället bör `remove_field()` och `add_field()` anropas separat.

Om databasen har `stödjer_kombinerade_alters`, kommer Django att försöka göra så många av dessa i ett enda databasanrop som möjligt; annars kommer det att utfärda en separat ALTER-sats för varje ändring, men kommer inte att utfärda ALTER där ingen ändring krävs.

## Attribut

Alla attribut ska betraktas som skrivskyddade om inget annat anges.

### `anslutning`

SchemaEditor.connection

Ett anslutningsobjekt till databasen. Ett användbart attribut för anslutningen är `alias` som kan användas för att bestämma namnet på den databas som nås.

Detta är användbart när du gör datamigreringar för migreringar med flera databaser.