SchemaEditor

class BaseDatabaseSchemaEditor[source]

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=())[source]

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.

skapa_modell()`

BaseDatabaseSchemaEditor.create_model(model)[source]

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

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

add_index()`

BaseDatabaseSchemaEditor.add_index(model, index)[source]

Lägger till index till model’s tabell.

remove_index()

BaseDatabaseSchemaEditor.remove_index(model, index)[source]

Tar bort index från modell:s tabell.

rename_index()

BaseDatabaseSchemaEditor.rename_index(model, old_index, new_index)[source]

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

add_constraint()

BaseDatabaseSchemaEditor.add_constraint(model, constraint)[source]

Lägger till constraint till model’s tabell.

remove_constraint()

BaseDatabaseSchemaEditor.remove_constraint(model, constraint)[source]

Tar bort constraint från model’s tabell.

alter_unique_together()

BaseDatabaseSchemaEditor.alter_unique_together(model, old_unique_together, new_unique_together)[source]

Ä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)[source]

Ä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)[source]

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

Ändra tabellkommentaren för model till new_db_table_comment.

alter_db_tablespace()

BaseDatabaseSchemaEditor.alter_db_tablespace(model, old_db_tablespace, new_db_tablespace)[source]

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

add_field()

BaseDatabaseSchemaEditor.add_field(model, field)[source]

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

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

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.