--- title: "Oibríochtaí Imirce" version: 6.0 locale: ga source: https://docs.djangoproject.com/ga/6.0/ref/migration-operations/ canonical: https://djangodocs.dev/ga/6.0/ref/migration-operations/ --- # Oibríochtaí Imirce Tá comhaid imirce comhdhéanta de Oibríocht amháin nó níos mó, rudaí a thaifeadann go dearbhaithe cad ba chóir don imirce a dhéanamh le do bhunachar sonraí. Úsáideann Django na rudaí Oibríochta seo freisin chun a fháil amach cén chuma atá ar do mhúnlaí go stairiúil, agus chun na hathruithe a rinne tú ar do mhúnlaí ón imirce deireanach a ríomh ionas gur féidir leis d'imirce a scríobh go huathoibríoch; sin an fáth go bhfuil siad dearbhaithe, mar ciallaíonn sé gur féidir le Django iad go léir a luchtú agus rith tríd gan teagmháil leis an mbunachar sonraí. \Tá rudaí Oibríocht speisialaithe ann freisin atá le haghaidh rudaí cosúil:ref: imirce sonraí agus le haghaidh ionramháil bunachar sonraí láimhe chun cinn. Is féidir leat do ranganna Oibríocht féin a scríobh freisin más mian leat athrú saincheaptha a dhéanann tú go coitianta a chuimsíonn tú. Má theastaíonn comhad imirce folamh uait chun do chuid rudaí ```Oibríochta ``féin a scríobh isteach, bain úsáid as `python manage.py makemigrations --empty yourappname```, ach bí ar an eolas gur féidir le hoibríochtaí athraithe scéime a chur mearbhall ar an uathbhreithnitheoir imirce agus rith a dhéanamh de:djadmin: makemigrations aschur mícheart. Tá gach ceann de na croí-oibríochtaí Django ar fáil ón modúl django.db.migrations.operations\`. Le haghaidh ábhar tosaigh, féach an:doc: treoir ábhair imirceach' \. ## Oibríochtaí Scéime ### `CreateModel` #### `class CreateModel(name, fields, options=None, bases=None, managers=None)` Cruthaíonn sé samhail nua i stair an tionscadail agus tábla comhfhreagrach sa bhunachar sonraí chun é a mheaitseáil. Is é ainm ainm an tsamhail, mar a scríobhfaí sa chomhad models.py. Is é `fields` liosta de dhá thiúpla de `(ainm réimse, field_instance)`. Ba chóir go mbeadh an t-áireamh réimse ina réimse neamhcheangailte (mar sin díreach Models.charfield (...) , seachas réimse a tógadh ó mhúnla eile). Is foclóir roghnach luachanna ó rang `Meta` an tsamhail is ea roghanna . Is liosta roghnach d'aicmí eile é `bases` chun an tsamhail seo a bheith oidhreachta uaidh; féadfaidh rudaí ranga a bheith ann chomh maith le teaghráin san fhormáid `"AppName.ModelName"` más mian leat brath ar mhúnla eile (ionas go n-oidhreann tú ón leagan stairiúil). Mura soláthraítear é, réamhshocraíonn sé oidhreacht ón gcaighdeánach Models.Model . Glacann ```bainisteoirí ``liosta de dhá thúpla de``` (ainm bainisteora, bainisteor\_instance) . Is é an chéad bhainisteoir ar an liosta an bainisteoir réamhshocraithe don tsamhail seo le linn imirce. ### `DeleteModel` #### `class DeleteModel(name)` Scriosann sé an tsamhail ó stair an tionscadail agus a tábla ón mbunachar sonraí. ### `Athainm Model` #### `class RenameModel(old_name, new_name)` Athainmníonn an tsamhail ó sheanainm go ceann nua. B'fhéidir go mbeidh ort é seo a chur leis de láimh má athraíonn tú ainm an tsamhail agus cúpla ceann dá réimsí ag an am céanna; chuig an autodetector, beidh cuma air seo gur scrios tú samhail leis an sean-ainm agus gur chuir tú ceann nua le ainm difriúil, agus caillfidh an imirce a chruthaíonn sé aon sonraí sa tseantábla. ### `AlterModelTable` #### `class AlterModelTable(name, table)` Athraíonn ainm tábla an tsamhail (an:attr: ~django.db.models.options.db\_table rogha ar an bhfo-aicme `Meta`). ### AlterModelTableComment \`\` #### `class AlterModelTableComment(name, table_comment)` Athraíonn sé trácht tábla an tsamhail (an rogha: attr: ~django.db.models.options.db\_table\_comment ar an bhfo-aicme `Meta`). ### `AlterUniquetogether` #### `class AlterUniqueTogether(name, unique_together)` Athraíonn sé tacar srianta uathúla an tsamhail (an rogha: attr: ~django.db.models.options.unique\_Together ar an bhfo-aicme `Meta`). ### `AlterIndexTogether` #### `class AlterIndexTogether(name, index_together)` Athraíonn sé tacar innéacsanna saincheaptha an tsamhail (an rogha index\_together ar an bhfo-aicme Meta\`). > **Warning** > > Ní thacaítear le AlterIndexTogether\` go hoifigiúil ach do chomhaid imirce réamh-Django 4.2. Ar chúiseanna comhoiriúnachta ar chúl, tá sé fós mar chuid den API poiblí, agus níl aon phlean ann é a dhíchur nó a bhaint, ach níor cheart é a úsáid le haghaidh imirce nua. Úsáid:aicme: ~django.db.migrations.operations.addIndex agus:class: ~django.db.migrations.operations.removeIndex oibríochtaí ina ionad. ### `AlterOrderWithReas` #### `class AlterOrderWithRespectTo(name, order_with_respect_to)` Déanann nó scriosann sé an colún `_order` is gá don rogha: attr: ~django.db.models.options.ORDER\_with\_RESPECT\_TO ar an bhfo-aicme `Meta`. ### `Roghanna AlterModel` #### `class AlterModelOptions(name, options)` Stórálann athruithe ar roghanna samhail ilghnéitheacha (socruithe ar Meta\` samhail) cosúil le ceadúna\` agus `verbose_name`. Ní dhéanann sé difear don bhunachar sonraí, ach leanann sé ar na hathruithe seo le haghaidh cásanna: class: RunPython le húsáid. Ba chóir go mbeadh roghanna ina fhoclóir a mhapáil ainmneacha roghanna ar luachanna. ### `Bainisteoirí AlterModel` #### `class AlterModelManagers(name, managers)` Athraíonn sé na bainisteoirí atá ar fáil le linn imirce. ### `Addfield` #### `class AddField(model_name, name, field, preserve_default=True)` Cuireann sé réimse le samhail. Is é `model_name` ainm an tsamhail, ```ainm ``is ainm an réimse, agus is sampla Réimse neamhcheangailte é ``field``` (an rud a chuirfeá sa dearbhú réimse i models.py\` \- mar shampla, `Models.IntegerField (Null=True)`. The `preserve_default` argument indicates whether the field's default value is permanent and should be baked into the project state (`True`), or if it is temporary and just for this migration (`False`) - usually because the migration is adding a non-nullable field to a table and needs a default value to put into existing rows. It does not affect the behavior of setting defaults in the database directly. > **Warning** > > Ar bhunachair sonraí níos sine, d'fhéadfadh réimse a chur leis le luach réamhshocraithe a bheith ina chúis le hathscríobh iomlán an tábla. Tarlaíonn sé seo fiú do réimsí in-neamhnaithe agus d'fhéadfadh tionchar diúltach feidhmíochta a bheith aige. Chun é sin a sheachaint, ba chóir na céimeanna seo a leanas a dhéanamh. > > - Cuir an réimse in-neamhnaithe leis gan an luach réamhshocraithe agus rith an t-ordú:djadmin: makemigrations. Ba chóir go mbeadh sé seo imirce a ghiniúint le hoibríocht AddField. > - Cuir an luach réamhshocraithe le do réimse agus rith an t-ordú:djadmin: makemigrations. Ba chóir go gcruthódh sé seo imirce le hoibríocht Alterfield\`. ### Réimse a bhaint \`\` #### `class RemoveField(model_name, name)` Baineann réimse as samhail. Cuimhnigh go bhfuil sé seo réimse a chur le samhail i ndáiríre nuair a aisiomptear é. Tá an oibríocht inchúlaithe (seachas aon chaillteanas sonraí, atá dochúlaithe) má tá an réimse in-neamhnaithe nó má tá luach réamhshocraithe aige is féidir a úsáid chun an colún athchruthaithe a líonadh. Mura bhfuil an réimse neamhnaithe agus mura bhfuil luach réamhshocraithe aige, tá an oibríocht dochúilte. > **Changed in Django 6.0** > > [`BaseDatabaseSchemaEditor`](/ga/6.0/ref/schema-editor/#django.db.backends.base.schema.BaseDatabaseSchemaEditor) and > PostgreSQL backends no longer use `CASCADE` to delete dependent related > database objects, such as views. Any dependent objects that are not managed > by Django may need to be removed manually before running `RemoveField`. ### `Alterfield` #### `class AlterField(model_name, name, field, preserve_default=True)` Athraíonn sé sainmhíniú réimse, lena n-áirítear athruithe ar a chineál, :attr: ~django.db.models.field.null, :attr: ~django.db.models.field.unique, :attr: ~django.db.models.field.db\_column agus tréithe réimse eile. The `preserve_default` argument indicates whether the field's default value is permanent and should be baked into the project state (`True`), or if it is temporary and just for this migration (`False`) - usually because the migration is altering a nullable field to a non-nullable one and needs a default value to put into existing rows. It does not affect the behavior of setting defaults in the database directly. Tabhair faoi deara nach féidir gach athrú a dhéanamh ar gach bunachar sonraí - mar shampla, ní féidir leat réimse cineál téacs mar Models.textField () \`\`a athrú go réimse cineál uimhreacha mar \`\`Models.IntegerField ()\` ar fhormhór na mbunachair sonraí. ### `Renamefield` #### `class RenameField(model_name, old_name, new_name)` Athraíonn ainm réimse (agus, unless:attr: ~django.db.models.field.db\_column socraítear, ainm a cholún). ### `AddIndex` #### `class AddIndex(model_name, index)` Cruthaíonn innéacs sa tábla bunachar sonraí don tsamhail le `model_name`. Is sampla den aicme:class: ~django.db.models.index is ea index\`. ### Táimhainnéacs \`\` #### `class RemoveIndex(model_name, name)` Baineann sé an t-innéacs darb ainm `ainm` ón tsamhail le `model_name`. ### `Renameindex` #### `class RenameIndex(model_name, new_name, old_name=None, old_fields=None)` Athainmnigh innéacs sa tábla bunachar sonraí don tsamhail le `model_name`. Is féidir ceann amháin de old\_name\` agus `old_fields` a sholáthar. Is é old\_fields\` athraitheach de na teaghráin, a fhreagraíonn go minic do réimsí index\_together (rogha réamh-DJango 5.1). On databases that don't support an index renaming statement (SQLite), the operation will drop and recreate the index, which can be expensive. ### Adsrianadh \`\` #### `class AddConstraint(model_name, constraint)` Cruthaíonn a:doc: sriant sa tábla bunachar sonraí \ don tsamhail le `model_name`. ### `Removeconstraint` #### `class RemoveConstraint(model_name, name)` Baineann sé an srian darb ainm ```ainm ``ón tsamhail le ``model_name```. ### `AlterConstraint` > **New in Django 5.2** #### `class AlterConstraint(model_name, name, constraint)` Alters the constraint named `name` of the model with `model_name` with the new `constraint` without affecting the database. ## Oibríochtaí Speisialta ### `Runsql` #### `class RunSQL(sql, reverse_sql=None, state_operations=None, hints=None, elidable=False)` Ceadaíonn sé SQL treallach a reáchtáil ar an mbunachar sonraí - úsáideach le haghaidh gnéithe níos airde de chúltaca bunachar sonraí nach dtacaíonn Django go díreach. Ba chóir go mbeadh sql\`, agus reverse\_sql\` má sholáthraítear iad, teaghráin SQL le rith ar an mbunachar sonraí. Ar fhormhór na gcúltaca bunachar sonraí (gach ceann ach PostgreSQL), roinnfidh Django an SQL ina ráitis aonair sula ndéanfaidh sé iad a fhorghníomhú. > **Warning** > > \Ar PostgreSQL agus SQLite, ní húsáid ach `BEGIN` nó COMMIT\` i do SQL in:ref: imirce neamh-adamhacha , chun staid idirbheart Django a bhriseadh a sheachaint. Is féidir leat liosta teaghráin nó 2-tuples a rith freisin. \Úsáidtear an dara ceann chun ceisteanna agus paraiméadair a rith ar an mbealach céanna amha:ref: cursor.execute () . Tá na trí oibríocht seo coibhéiseach: ``` migrations.RunSQL("INSERT INTO musician (name) VALUES ('Reinhardt');") migrations.RunSQL([("INSERT INTO musician (name) VALUES ('Reinhardt');", None)]) migrations.RunSQL([("INSERT INTO musician (name) VALUES (%s);", ["Reinhardt"])]) ``` Más mian leat comharthaí faoin gcéad liteartha a áireamh sa cheist, caithfidh tú iad a dhúbailt má tá tú ag dul ar pharaiméadair. Déantar na ceisteanna reverse\_sql\` a fhorghníomhú nuair nach ndéantar an imirce a chur i bhfeidhm. Ba chóir dóibh an méid a dhéanann na ceisteanna sql a chealú. Mar shampla, chun an t-ionchur thuas a chealú le scriosadh: ``` migrations.RunSQL( sql=[("INSERT INTO musician (name) VALUES (%s);", ["Reinhardt"])], reverse_sql=[("DELETE FROM musician where name=%s;", ["Reinhardt"])], ) ``` Más é `reverse_sql` `None` (an réamhshocraithe), tá an oibríocht `Runsql` dochúlghabháilte. Ligeann an argóint state\_operations\` duit oibríochtaí atá comhionann leis an SQL a sholáthar i dtéarmaí staid an tionscadail. Mar shampla, má tá colún á chruthú agat de láimh, ba chóir duit dul isteach i liosta ina bhfuil oibríocht Addfield anseo ionas go mbeidh staid cothrom le dáta den tsamhail fós ag an uathbhreithnitheoir. Mura ndéanann tú, nuair a reáchtálann tú makemigrations eile, ní fheicfidh sé aon oibríocht a chuireann an réimse sin leis agus mar sin déanfaidh sé iarracht é a reáchtáil arís. Mar shampla: ``` migrations.RunSQL( "ALTER TABLE musician ADD COLUMN name varchar(255) NOT NULL;", state_operations=[ migrations.AddField( "musician", "name", models.CharField(max_length=255), ), ], ) ``` Cuirfear an argóint roghnach ```leideanna ``ar aghaidh mar `**hints``` chuig an modh:meth: allow\_migrate de ródairí bunachar sonraí chun cabhrú leo cinntí ródaithe a dhéanamh. Féach:ref: topics-db-multi-db-hints le haghaidh tuilleadh sonraí ar leideanna bunachar sonraí. \Cinneann an argóint roghnach `elidable` cibé an mbainfear an oibríocht nó nach ndéanfar an oibríocht nuai:ref: imirce squashing . #### `RunSQL.noop` Pas an tréith `Runsql.noop` go sql\` nó `reverse_sql` nuair a theastaíonn uait gan an oibríocht aon rud a dhéanamh sa treo ar leith. Tá sé seo úsáideach go háirithe chun an oibríocht a dhéanamh inchúlaithe. ### `Runpython` #### `class RunPython(code, reverse_code=None, atomic=None, hints=None, elidable=False)` Ritheann sé cód saincheaptha Python i gcomhthéacs stairiúil. \Ba chóir go mbeadh “code” (agus reverse\_code\` má sholáthraítear) a ghlacann le dhá argóint; is sampla de Django.Apps.Registry.apps\` é an chéad cheann ina bhfuil samhlacha stairiúla a mheaitseálann áit na hoibríochta i stair an tionscadail, agus is é an dara ceann de: class: SchemaEditor. Tugtar ar an argóint reverse\_code\` nuair a dhéantar imirce a chur i bhfeidhm. Ba chóir don ghlaoiteoir seo an méid a dhéantar sa ```cód ``inghlaochta a chealú ionas go mbeidh an imirce inchúlaithe. Más é ``reverse_code``` `None` (an réamhshocraithe), ní féidir an oibríocht `RunPython` dochúlghabháilte. Cuirfear an argóint roghnach ```leideanna ``ar aghaidh mar `**hints``` chuig an modh:meth: allow\_migrate de ródairí bunachar sonraí chun cabhrú leo cinneadh ródaithe a dhéanamh. Féach:ref: topics-db-multi-db-hints le haghaidh tuilleadh sonraí ar leideanna bunachar sonraí. \Cinneann an argóint roghnach `elidable` cibé an mbainfear an oibríocht nó nach ndéanfar an oibríocht nuai:ref: imirce squashing . Moltar duit an cód a scríobh mar fheidhm ar leithligh os cionn an aicme `Imigration` sa chomhad imirce, agus é a chur chuig Runpython\`. Seo sampla de `Runpython` a úsáid chun roinnt rudaí tosaigh a chruthú ar mhúnla Tír : ``` from django.db import migrations def forwards_func(apps, schema_editor): # We get the model from the versioned app registry; # if we directly import it, it'll be the wrong version Country = apps.get_model("myapp", "Country") db_alias = schema_editor.connection.alias Country.objects.using(db_alias).bulk_create( [ Country(name="USA", code="us"), Country(name="France", code="fr"), ] ) def reverse_func(apps, schema_editor): # forwards_func() creates two Country instances, # so reverse_func() should delete them. Country = apps.get_model("myapp", "Country") db_alias = schema_editor.connection.alias Country.objects.using(db_alias).filter(name="USA", code="us").delete() Country.objects.using(db_alias).filter(name="France", code="fr").delete() class Migration(migrations.Migration): dependencies = [] operations = [ migrations.RunPython(forwards_func, reverse_func), ] ``` De ghnáth is é seo \an oibríocht a úsáideann tú chun: ref: imirce sonraí a chruthú, nuashonruithe agus athruithe sonraí saincheaptha a reáchtáil, agus aon rud eile a theastaíonn uait rochtain ar chód ORM agus/nó Python dó. Cosúil le: class: Runsql, cinntigh má athraíonn tú scéim taobh istigh anseo go bhfuil tú ag déanamh taobh amuigh de scóip chórais samhail Django (m.sh. spreagthóirí) nó go n-úsáideann tú: class: SeparateDatabaseandState chun oibríochtaí a chur isteach a léireoidh do chuid athruithe ar an stát samhail - ar shlí eile, stopfaidh an ORM leaganaithe agus an autodetector ag obair i gceart. De réir réamhshocraithe, reáchtálfaidh `RunPython` a ábhar taobh istigh d'idirbheart ar bhunachair sonraí nach dtacaíonn le hidirbhearta DDL (mar shampla, MySQL agus Oracle). Ba chóir go mbeadh sé seo sábháilte, ach féadfaidh sé timpiste a bheith ina chúis má dhéanann tú iarracht an schema\_editor\` a chuirtear ar fáil ar na cúltaca seo a úsáid; sa chás seo, cuir `Atomic=False` chuig an oibríocht `RunPython`. Ar bhunachair sonraí a thacaíonn le hidirbhearta DDL (SQLite agus PostgreSQL), níl aon idirbhearta curtha leis go huathoibríoch ar oibríochtaí Runpython seachas na hidirbhearta a cruthaíodh do gach imirce. Dá bhrí sin, ar PostgreSQL, mar shampla, ba cheart duit athruithe scéime agus oibríochtaí `RunPython` a chomhcheangal san imirce céanna nó féadfaidh tú earráidí mar OperationalError: can't ALTER TABLE “mytable” toisc go bhfuil imeachtaí truiceacha ar feitheamh aige \`. Má tá bunachar sonraí difriúil agat agus mura bhfuil tú cinnte an dtacaíonn sé le hidirbhearta DDL, seiceáil an tréith `django.db.connection.features.can_rollback_ddl`. Má tá an oibríocht `RunPython` mar chuid de a:ref: imirce neamh-adamh\`\, ní fhorghníomhfar an oibríocht ach in idirbheart má chuirtear \`\`Atomic=True\` chuig an oibríocht `RunPython`. > **Warning** > > Ní athraíonn `RunPython` nasc na samhlacha duit go draíochta; rachaidh aon mhodhanna samhail a ghlaonn tú chuig an mbunachar sonraí réamhshocraithe mura dtugann tú an alias bunachar sonraí reatha dóibh (ar fáil ó schema\_editor.connection.alias\`, áit is é schema\_editor an dara argóint le do fheidhm). #### `static RunPython.noop()` Pas an modh `Runpython.noop` go code\` nó `reverse_code` nuair is mian leat gan an oibríocht aon rud a dhéanamh sa treo ar leith. Tá sé seo úsáideach go háirithe chun an oibríocht a dhéanamh inchúlaithe. ### ScaoilteDatabaseandstát \`\` #### `class SeparateDatabaseAndState(database_operations=None, state_operations=None)` Oibríocht an-speisialaithe a ligeann duit gnéithe na hoibríochtaí bunachar sonraí (ag athrú scéime) agus stáit (cumhacht uathbhreithadóir) a mheascadh agus a mheaitseáil. Glacann sé le dhá liosta oibríochtaí. Nuair a iarrtar sé stát a chur i bhfeidhm, úsáidfidh sé an liosta `state_operations` (is leagan ginearálta é seo d'argóint `state_operations` class: \`RunSQL). Nuair a iarrtar ar athruithe a chur i bhfeidhm ar an mbunachar sonraí, úsáidfidh sé an liosta database\_operations\`. Má éiríonn staid iarbhír an bhunachar sonraí agus dearcadh Django ar an stát as sioncrónú, féadfaidh sé seo an creat imirce a bhriseadh, fiú caillteanas sonraí a bheith mar thoradh air. Is fiú cúramach a bheith agat agus d'oibríochtaí bunachar sonraí agus stáit a sheiceáil go cúramach. Is féidir leat: djadmin: sqlmigrate agus:djadmin: dbshell a úsáid chun d'oibríochtaí bunachar sonraí a sheiceáil. \Is féidir leat: djadmin: makemigrations a úsáid, go háirithe le:option: --dry-run , chun d'oibríochtaí stáit a sheiceáil. Mar shampla ag baint úsáide as `SeparatedAtabaseandState`, féach:ref: changing-a-manytomanyfield-to-use-a-through-model. ## Catagóir oibríochta #### `class OperationCategory` Catagóirí oibríochta imirce a úsáidtear ag an ordú:djadmin: makemigrations chun siombailí bríocha a thaispeáint. #### `ADDITION` *Siombail*: `+` #### `REMOVAL` *Siombail*: `-` #### `ALTERATION` *Siombail*: `~` #### `PYTHON` *Siombail*: `p` #### `SQL` *Siombail*: `s` #### `MIXED` *Siombail*: ? \`\` ## Do chuid féin a scríobh Tá API réasúnta simplí ag oibríochtaí, agus tá siad deartha ionas gur féidir leat do chuid féin a scríobh go héasca chun na cinn Django ionsuite a fhorlíonadh. Breathnaíonn struchtúr bunúsach Oibríocht' mar seo: ``` from django.db.migrations.operations.base import Operation class MyCustomOperation(Operation): # If this is False, it means that this operation will be ignored by # sqlmigrate; if true, it will be run and the SQL collected for its output. reduces_to_sql = False # If this is False, Django will refuse to reverse past this operation. reversible = False # This categorizes the operation. The corresponding symbol will be # displayed by the makemigrations command. category = OperationCategory.ADDITION def __init__(self, arg1, arg2): # Operations are usually instantiated with arguments in migration # files. Store the values of them on self for later use. pass def state_forwards(self, app_label, state): # The Operation should take the 'state' parameter (an instance of # django.db.migrations.state.ProjectState) and mutate it to match # any schema changes that have occurred. pass def database_forwards(self, app_label, schema_editor, from_state, to_state): # The Operation should use schema_editor to apply any changes it # wants to make to the database. pass def database_backwards(self, app_label, schema_editor, from_state, to_state): # If reversible is True, this is called when the operation is reversed. pass def describe(self): # This is used to describe what the operation does. return "Custom Operation" @property def migration_name_fragment(self): # Optional. A filename part suitable for automatically naming a # migration containing this operation, or None if not applicable. return "custom_operation_%s_%s" % (self.arg1, self.arg2) ``` Is féidir leat an teimpléad seo a thógáil agus oibriú uaidh, cé go molaimid féachaint ar na hoibríochtaí ionsuite Django i django.db.migrations.operations\` \- clúdaíonn siad go leor den úsáid shamplach gnéithe leath-inmheánacha den chreat imirce cosúil le Project\`state \`agus na patrúin a úsáidtear chun samhlacha stairiúla a fháil, chomh maith le \`ModelState agus na patrúin a úsáidtear chun samhlacha stairiúla a athrú ar aghaidh () . Roinnt rudaí le tabhairt faoi deara: - Ní gá duit an iomarca a fhoghlaim faoi ProjectState\` chun imirce a scríobh; níl a fhios agat ach go bhfuil maoin apps \`\`aipeanna aige a thugann rochtain ar chlárlann aipeanna (ar féidir leat \`\`get\_model\` a ghlaoch ansin air). - Faigheann `database_forwards` agus database\_backwards\` dhá stát ar aghaidh chucu; léiríonn siad seo an difríocht a bheadh i bhfeidhm ag an modh state\_forward , ach tugtar duit ar chúiseanna áisiúlachta agus luais. - Más mian leat oibriú le ranganna samhail nó cásanna samhail ón argóint ```from_state ``i `database_forwards ()``` nó database\_backwards () \`, ní mór duit stáit samhail a thabhairt ag baint úsáide as an modh `clear_delayed_apps_cache ()` chun samhlacha gaolmhara a chur ar fáil: ``` def database_forwards(self, app_label, schema_editor, from_state, to_state): # This operation should have access to all models. Ensure that all models are # reloaded in case any are delayed. from_state.clear_delayed_apps_cache() ... ``` - Is é to\_state sa mhodh database\_backwards an stát\*níos sine; is é sin, an ceann a bheidh mar an staid reatha nuair a bheidh an imirce críochnaithe ag aisiompú. - B'fhéidir go bhfeicfeá cur i bhfeidhm `references_model` ar na hoibríochtaí ionsuite; is cuid den chód uathbhreithnithe é seo agus níl sé tábhacht le haghaidh oibríochtaí saincheaptha. > **Warning** > > Ar chúiseanna feidhmíochta, athúsáidtear na cásanna: class: ~django.db.models.field i ModelState.Field trasna imirce. Ní mór duit na tréithe ar na cásanna seo a athrú riamh. Más gá duit réimse a athrú in state\_forwards () \`, ní mór duit an seanshampla a bhaint as ModelState.fields\` agus cás nua a chur ina áit. Tá an rud céanna fíor maidir leis na cásanna: class: ~Django.db.Models.Manager i ModelState.Manager. Mar shampla, déanaimis oibríocht a luchtaíonn síntí PostgreSQL (ina bhfuil cuid de na gnéithe níos spreagúla PostgreSQL). Ós rud é nach bhfuil aon athruithe stáit samhail ann, níl le déanamh aige ach ordú amháin a reáchtáil: ``` from django.db.migrations.operations.base import Operation class LoadExtension(Operation): reversible = True def __init__(self, name): self.name = name def state_forwards(self, app_label, state): pass def database_forwards(self, app_label, schema_editor, from_state, to_state): schema_editor.execute("CREATE EXTENSION IF NOT EXISTS %s" % self.name) def database_backwards(self, app_label, schema_editor, from_state, to_state): schema_editor.execute("DROP EXTENSION %s" % self.name) def describe(self): return "Creates extension %s" % self.name @property def migration_name_fragment(self): return "create_extension_%s" % self.name ```