djangodocs

Django 5.2
Gaeilge
Documentation contents

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í.

<data-migrations>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' </topics/migrations>.

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`).

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).

Léiríonn an argóint preserve_default` an bhfuil luach réamhshocraithe an réimse buan agus ba chóir é a bhácáil isteach i stát an tionscadail (True`), nó má tá sé sealadach agus díreach don imirce seo (False`) - de ghnáth toisc go bhfuil réimse neamh-neamhrialaithe ag cur le tábla agus teastaíonn luach réamhshocraithe a chur sna sraitheanna atá ann cheana. Ní dhéanann sé difear go díreach ar iompar réamhshocruithe a shocrú sa bhunachar sonraí - ní shocraíonn Django réamhshocraithe bunachar sonraí riamh agus cuireann sé i bhfeidhm iad i gcónaí sa chód ORM Django.

``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.

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.

Léiríonn an argóint preserve_default` an bhfuil luach réamhshocraithe an réimse buan agus ba chóir é a bhácáil isteach i stát an tionscadail (True`), nó má tá sé sealadach agus díreach don imirce seo (False`) - de ghnáth toisc go bhfuil an imirce ag athrú réimse neamh-innithe agus teastaíonn luach réamhshocraithe a chur sna sraitheanna atá ann cheana. Ní dhéanann sé difear go díreach ar iompar réamhshocruithe a shocrú sa bhunachar sonraí - ní shocraíonn Django réamhshocraithe bunachar sonraí riamh agus cuireann sé i bhfeidhm iad i gcónaí sa chód ORM Django.

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).

Ar bhunachair sonraí nach dtacaíonn le ráiteas athainmnithe innéacs (SQLite agus MariaDB <10.5.2), titeoidh an oibríocht an t-innéacs agus a athchruthú, rud a d'fhéadfadh a bheith daor.

``Adsrianadh ``

class AddConstraint(model_name, constraint)

Cruthaíonn a:doc: sriant sa tábla bunachar sonraí </ref/models/constraints> don tsamhail le model_name.

Removeconstraint

class RemoveConstraint(model_name, name)

Baineann sé an srian darb ainm ainm ``ón tsamhail le ``model_name.

AlterConstraint

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ú.

Is féidir leat liosta teaghráin nó 2-tuples a rith freisin. <executing-custom-sql>Ú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:

Code
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:

Code
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:

Code
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í.

<migration-squashing>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. <django.db.backends.base.schema.BaseDatabaseSchemaEditor>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í.

<migration-squashing>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 ``:

Code
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 <data-migrations>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`<non-atomic-migrations>, ní fhorghníomhfar an oibríocht ach in idirbheart má chuirtear ``Atomic=True` chuig an oibríocht RunPython.

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. <makemigrations --dry-run>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:

Code
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:

    Code
    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.

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:

Code
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
View as Markdown Edit this page on GitHub Official version