djangodocs

Django 5.2
Gaeilge
Documentation contents

Bunachair sonraí iliom

Déanann an treoir ábhair seo cur síos ar thacaíocht Django chun idirghníomhú le bunachair Glacann an chuid is mó den chuid eile de dhoiciméadú Django go bhfuil tú ag idirghníomhú le bunachar sonraí amháin. Más mian leat idirghníomhú le bunachair sonraí iolracha, beidh ort roinnt céimeanna breise a ghlacadh.

Sainmhíniú do bhunachar

Is é an chéad chéim chun níos mó ná bunachar sonraí amháin a úsáid le Django ná insint do Django faoi na freastalaithe bunachar sonraí a bheidh á úsáid agat. Déantar é seo ag baint úsáide as an socrú:setting: DATABASES. Déanann an socrú seo mapáil ainmneacha bunachar sonraí, ar bealach iad chun tagairt a dhéanamh do bhunachar sonraí ar leith ar fud Django, chuig foclóir socruithe don nasc sonrach sin. Déantar cur síos iomlán ar na socruithe sna foclóirí istigh sa doiciméadach:setting: DATABASES.

Is féidir le bunachair sonraí aon ainm a roghnaíonn tú a bheith Mar sin féin, tá tábhacht speisialta ag an alias default. Úsáideann Django an bunachar sonraí leis an alias de default nuair nach roghnaíodh aon bhunachar sonraí eile.

Seo a leanas sampla settings.py snippet a shainmhíníonn dhá bhunachar sonraí - bunachar sonraí réamhshocraithe PostgreSQL agus bunachar sonraí MySQL ar a dtugtar users:

Code
DATABASES = {
    "default": {
        "NAME": "app_data",
        "ENGINE": "django.db.backends.postgresql",
        "USER": "postgres_user",
        "PASSWORD": "s3krit",
    },
    "users": {
        "NAME": "user_data",
        "ENGINE": "django.db.backends.mysql",
        "USER": "mysql_user",
        "PASSWORD": "priv4te",
    },
}

Mura bhfuil ciall ag coincheap bunachar sonraí réamhshocraithe` i gcomhthéacs do thionscadail, ní mór duit a bheith cúramach an bunachar sonraí a theastaíonn uait a úsáid a shonrú i gcónaí. Éilíonn Django go ndéanfar iontráil bunachar sonraí default` a shainiú, ach is féidir foclóir na paraiméadair a fhágáil bán mura n-úsáidfear é. Chun seo a dhéanamh, ní mór duit:setting: `DATABASE_ROUTERS` a chur ar bun do mhúnlaí uile d'aipeanna, lena n-áirítear iad siúd in aon aipeanna contrib agus tríú páirtí atá á úsáid agat, ionas nach ndéanfar aon cheisteanna a atreorú chuig an mbunachar sonraí réamhshocraithe. Seo a leanas sampla ``settings.py snippet a shainmhíníonn dhá bhunachar sonraí neamh-réamhshocraithe, agus an iontráil default fágtha folamh d'aon ghnó:

Code
DATABASES = {
    "default": {},
    "users": {
        "NAME": "user_data",
        "ENGINE": "django.db.backends.mysql",
        "USER": "mysql_user",
        "PASSWORD": "superS3cret",
    },
    "customers": {
        "NAME": "customer_data",
        "ENGINE": "django.db.backends.mysql",
        "USER": "mysql_cust",
        "PASSWORD": "veryPriv@ate",
    },
}

Má dhéanann tú iarracht rochtain a fháil ar bhunachar sonraí nach bhfuil sainmhínithe agat i do shuíomh: DATABASES, ardóidh Django eisceacht ``Django.Utils.CONNECTION.CONNECTIONDOESNOTEXIST ``.

Sioncrónú do bhunachar sonraí

Feidhmíonn an t-ordú bainistíochta: DJADmin: imirce ar bhunachar sonraí amháin ag an am. De réir réamhshocraithe, oibríonn sé ar an mbunachar sonraí réamhshocraithe, ach tríd an rogha: `--database `a sholáthar, is féidir leat a rá dó bunachar sonraí difriúil a <migrate --database>shioncronú. Mar sin, chun gach samhail a shioncronú ar gach bunachar sonraí sa chéad shampla thuas, bheadh ort glaoch ar:

Shell
$ ./manage.py migrate
$ ./manage.py migrate --database=users

Mura dteastaíonn uait go ndéanfaí gach feidhmchlár a shioncronú le bunachar sonraí áirithe, is féidir leat a: ref: `ródaire bunachar sonraí <topics-db-multi-db-routing>`a shainiú a chuireann beartas i bhfeidhm ag cur srian ar infhaighteacht samhlacha áirithe.

Má d'fhág tú, mar atá sa dara sampla thuas, an bunachar sonraí default folamh, ní mór duit ainm bunachar sonraí a sholáthar gach uair a rith tú: djadmin: migrate. Trí ainm an bhunachar sonraí a fhágáil, d'ardódh earráid. Maidir leis an dara sampla:

Shell
$ ./manage.py migrate --database=users
$ ./manage.py migrate --database=customers

Orduithe bainistíochta eile a úsáid

Oibríonn an chuid is mó d'orduithe django-admin ``eile a idirghníomhaíonn leis an mbunachar sonraí ar an mbealach céanna le: djadmin: `migrate` - ní oibríonn siad riamh ar bhunachar sonraí amháin ag an am, ag baint úsáide as ``- bunachar sonraí chun an bunachar sonraí a úsáidtear a rialú.

Eisceacht ón riail seo is ea an t-ordú:djadmin: makemigrations. Bailíonn sé stair na himirce sna bunachair sonraí chun fadhbanna a ghabháil leis na comhaid imirce atá ann cheana féin (a d'fhéadfadh a bheith mar thoradh orthu a chur in eagar) sula gcruthaítear imirce nua. <topics-db-multi-db-routing>De réir réamhshocraithe, ní sheiceálann sé ach an bunachar sonraí ``default`, ach déanann sé dul i gcomhairle leis an modh:meth: allow_migrate de:ref: ródair má tá aon cheann suiteáilte.

Ródú uathoibríoch bunachar

Is é an bealach is éasca le bunachair sonraí iolracha a úsáid ná scéim ródaithe bunachar sonraí a bhunú. Cinntíonn an scéim ródaithe réamhshocraithe go bhfanann rudaí 'greamaitheach' lena mbunachar sonraí bunaidh (ie, sábhálfar réad a aisghabhadh ón mbunachar sonraí foo' ar an mbunachar sonraí céanna). Cinntíonn an scéim ródaithe réamhshocraithe mura sonraítear bunachar sonraí, go dtagann gach ceist ar ais chuig an mbunachar sonraí `réamhshocraithe`.

Ní gá duit aon rud a dhéanamh chun an scéim ródaithe réamhshocraithe a ghníomhachtú - cuirtear ar fáil í 'amach as an mbosca' ar gach tionscadal Django. Mar sin féin, más mian leat iompraíochtaí leithdháileadh bunachar sonraí níos spéisiúla a chur i bhfeidhm, is féidir leat do ródairí bunachar sonraí féin a shainiú agus

Ródaithe bunachar sonraí

Is rang é Ródaire bunachar sonraí a sholáthraíonn suas le ceithre mhodh:

db_for_read(model, **hints)

Moltar an bunachar sonraí ba chóir a úsáid le haghaidh oibríochtaí léitheoireachta le haghaidh rudaí de chineál ``samhail`.

Má tá oibríocht bunachar sonraí in ann aon fhaisnéis bhreise a sholáthar a d'fhéadfadh cabhrú le bunachar sonraí a roghnú, cuirfear ar fáil sa bhfoclóir ``leideanna ``. <topics-db-multi-db-hints>Cuirtear sonraí ar leideanna bailí ar fáil: ref: `thíos `.

Tugann sé ar ais None mura bhfuil aon mholadh ann.

db_for_write(model, **hints)

Moltar an bunachar sonraí ba chóir a úsáid le haghaidh scríobh rudaí de chineál Samhail.

Má tá oibríocht bunachar sonraí in ann aon fhaisnéis bhreise a sholáthar a d'fhéadfadh cabhrú le bunachar sonraí a roghnú, cuirfear ar fáil sa bhfoclóir ``leideanna ``. <topics-db-multi-db-hints>Cuirtear sonraí ar leideanna bailí ar fáil: ref: `thíos `.

Tugann sé ar ais None mura bhfuil aon mholadh ann.

allow_relation(obj1, obj2, **hints)

Tabhair ar ais True má chóir gaol idir obj1 agus obj2` a cheadú, Fal má chóir an gaol a chosc, nó None mura bhfuil aon tuairim ag an ródaire. Is oibríocht bailíochtaithe amháin é seo, a úsáidtear ag eochair eachtrach agus go leor oibríochtaí chun a chinneadh an cheart caidreamh a cheadú idir dhá réad.

Mura bhfuil tuairim ag aon ródaire (ie filleann gach ródaire ``None ``), ní cheadaítear ach caidreamh laistigh den bhunachar sonraí céanna.

allow_migrate(db, app_label, model_name=None, **hints)

Faigh amach an gceadaítear don oibríocht imirce a reáchtáil ar an mbunachar sonraí le alias db. Fill ar ais True más chóir go rithfeadh an oibríocht, False mura chóir dó rith, nó None mura bhfuil aon tuairim ag an ródaire.

Is é an argóint seasaimh app_label` lipéad an fheidhmchláir atá á imirce.

Socraítear model_name ag an gcuid is mó d'oibríochtaí imirce go luach samhail. _meta.model_name (an leagan íseal den tsamhail __name__) den tsamhail atá á imirce. Is é a luach None d'oibríochtaí: ~django.db.migrations.operations.runpython agus:class: ~django.db.migrations.operations.runsql mura soláthraíonn siad é ag baint úsáide as leideanna.

Úsáideann oibríochtaí áirithe ``leideanna ``chun faisnéis bhreise a chur in iúl don ródaire.

Nuair a shocraítear model_name, is gnách go mbíonn hints an rang samhail faoin eochair `samhail. Tabhair faoi deara go bhféadfadh sé a: ref: samhail stairiúil <historical-models>, agus dá bhrí sin nach bhfuil aon tréithe, modhanna nó bainisteoirí saincheaptha aige. Níor chóir duit brath ach ar _meta.

Is féidir an modh seo a úsáid freisin chun infhaighteacht samhail ar bhunachar sonraí ar leith a chinneadh.

makemigrations always creates migrations for model changes, but if allow_migrate() returns False, any migration operations for the model_name will be silently skipped when running migrate on the db. Changing the behavior of allow_migrate() for models that already have migrations may result in broken foreign keys, extra tables, or missing tables. When makemigrations verifies the migration history, it skips databases where no app is allowed to migrate.

Ní gá do ródaire na modhanna seo uach* a sholáthar - féadfaidh sé ceann amháin nó níos mó acu a fhágáil. Má fhágtar ceann de na modhanna, scipeánfaidh Django an ródaire sin agus an seiceáil ábhartha á ndéanamh agat.

Leideanna

Is féidir na leideanna a fhaigheann an ródaire bunachar sonraí a úsáid chun cinneadh a dhéanamh cén bunachar sonraí ba chóir iarratas ar leith a fháil.

Faoi láthair, is é an t-aon leid a chuirfear ar fáil ná instance, sampla réada a bhaineann leis an oibríocht léitheoireachta nó scríbhneoireachta atá ar siúl. D'fhéadfadh gurb é seo an cás atá á shábháil, nó d'fhéadfadh sé a bheith ina sampla atá á chur leis i ngaol go leor. I roinnt cásanna, ní chuirfear aon leid ar fáil ar chor ar bith. Seiceálann an ródaire go bhfuil leid shampla ann, agus cinneann sé an cheart an leid sin a úsáid chun iompar ródúcháin a athrú.

Úsáid ródairí

Suiteáiltear ródairí bunachar sonraí ag baint úsáide as an socrú: setting: DATABASE_ROUTERS. Sainmhíníonn an socrú seo liosta d'ainmneacha ranga, gach ceann acu ag sonrú ródaire ar chóir an bunródaire a úsáid (django.db.router).

Úsáideann oibríochtaí bunachar sonraí Django an ródaire bunachar sonraí chun úsáid bunachar sonraí a leithdháileadh. Aon uair a chaithfidh fiosrúchán a fháil amach cén bunachar sonraí atá le húsáid, glaonn sé ar an ródaire bonn, ag soláthar samhail agus leid (má tá sé ar fáil). Déanann an bunródaire iarracht gach rang ródaire ina dhiaidh sin go dtí go bhfilleann duine moladh bunachar sonraí. Mura dtugann aon ródairí moladh ar ais, déanann an ródaire bonn iarracht an reatha: attr: instance. _state.db <django.db.models.Model._state>`den chás leideanna. Mura soláthraíodh aon sampla leideanna, nó:attr: `instance. Is é _state.db <django.db.models.Model._state>```None `, leithdháileoidh an bunródaire an bunachar sonraí réamhshocraithe.

Sampla

Mar sin - cad a chiallaíonn sé seo i gcleachtas? Déanaimis smaoineamh ar chumraíocht samplach eile. Beidh roinnt bunachar sonraí ag an gceann seo: ceann don fheidhmchlár ``auth`, agus gach aip eile ag baint úsáide as socrú bunscoil/macasamhail le dhá mhacasamhail léite. Seo na socruithe a shonraíonn na bunachair sonraí seo:

Code
DATABASES = {
    "default": {},
    "auth_db": {
        "NAME": "auth_db_name",
        "ENGINE": "django.db.backends.mysql",
        "USER": "mysql_user",
        "PASSWORD": "swordfish",
    },
    "primary": {
        "NAME": "primary_name",
        "ENGINE": "django.db.backends.mysql",
        "USER": "mysql_user",
        "PASSWORD": "spam",
    },
    "replica1": {
        "NAME": "replica1_name",
        "ENGINE": "django.db.backends.mysql",
        "USER": "mysql_user",
        "PASSWORD": "eggs",
    },
    "replica2": {
        "NAME": "replica2_name",
        "ENGINE": "django.db.backends.mysql",
        "USER": "mysql_user",
        "PASSWORD": "bacon",
    },
}

Anois beidh orainn ródú a láimhseáil. Ar dtús ba mhaith linn ródaire a bhfuil a fhios aige ceisteanna a sheoladh do na feidhmchláir auth` agus contenttypes` chuig auth_db` (tá samhlacha auth` nasctha le contentType`, mar sin caithfear iad a stóráil sa bhunachar sonraí céanna):

Code
class AuthRouter:
    """
    A router to control all database operations on models in the
    auth and contenttypes applications.
    """

    route_app_labels = {"auth", "contenttypes"}

    def db_for_read(self, model, **hints):
        """
        Attempts to read auth and contenttypes models go to auth_db.
        """
        if model._meta.app_label in self.route_app_labels:
            return "auth_db"
        return None

    def db_for_write(self, model, **hints):
        """
        Attempts to write auth and contenttypes models go to auth_db.
        """
        if model._meta.app_label in self.route_app_labels:
            return "auth_db"
        return None

    def allow_relation(self, obj1, obj2, **hints):
        """
        Allow relations if a model in the auth or contenttypes apps is
        involved.
        """
        if (
            obj1._meta.app_label in self.route_app_labels
            or obj2._meta.app_label in self.route_app_labels
        ):
            return True
        return None

    def allow_migrate(self, db, app_label, model_name=None, **hints):
        """
        Make sure the auth and contenttypes apps only appear in the
        'auth_db' database.
        """
        if app_label in self.route_app_labels:
            return db == "auth_db"
        return None

Agus theastaíonn ródaire uainn freisin a sheolann gach aip eile chuig an gcumraíocht bunscoil/macasamhail, agus a roghnaíonn macasamhail go randamach le léamh as:

Code
import random


class PrimaryReplicaRouter:
    def db_for_read(self, model, **hints):
        """
        Reads go to a randomly-chosen replica.
        """
        return random.choice(["replica1", "replica2"])

    def db_for_write(self, model, **hints):
        """
        Writes always go to primary.
        """
        return "primary"

    def allow_relation(self, obj1, obj2, **hints):
        """
        Relations between objects are allowed if both objects are
        in the primary/replica pool.
        """
        db_set = {"primary", "replica1", "replica2"}
        if obj1._state.db in db_set and obj2._state.db in db_set:
            return True
        return None

    def allow_migrate(self, db, app_label, model_name=None, **hints):
        """
        All non-auth models end up in this pool.
        """
        return True

Faoi dheireadh, sa chomhad socruithe, cuirimid an méid seo a leanas leis (ag cur path.to.` in ionad an cosán Python iarbhír chuig an modúl (í) ina bhfuil na ródairí sainmhínithe):

Code
DATABASE_ROUTERS = ["path.to.AuthRouter", "path.to.PrimaryReplicaRouter"]

Tá an t-ord ina ndéantar ródairí a phróiseáil suntasach. Cuirfear ceist ar ródairí san ord atá siad liostaithe sa socrú: SETTING: DATABASE_ROUTERS. Sa sampla seo, déantar an Authrough ``a phróiseáil roimh an ``PrimaryRepliCarouter`, agus mar thoradh air sin, déantar cinntí a bhaineann leis na samhlacha in auth a phróiseáil sula ndéantar aon chinneadh eile. Má liostaíodh an socrú:setting: DATABASE_ROUTERS an dá ródaire san ord eile, bheadh `primaryReplicaRouter.ALLOW_MIGRATE () ``a phróiseáil ar dtús. Ciallaíonn nádúr uile an chur i bhfeidhm PrimaryReplicaOuter go mbeadh na samhlacha go léir ar fáil ar gach bunachar sonraí.

Leis an socrú seo suiteáilte, agus na bunachair sonraí go léir a imirceadh mar: ref: synchronizing_multiple_databases, ligeann sé roinnt cód Django a reáchtáil:

Python console
>>> # This retrieval will be performed on the 'auth_db' database
>>> fred = User.objects.get(username="fred")
>>> fred.first_name = "Frederick"

>>> # This save will also be directed to 'auth_db'
>>> fred.save()

>>> # These retrieval will be randomly allocated to a replica database
>>> dna = Person.objects.get(name="Douglas Adams")

>>> # A new object has no database allocation when created
>>> mh = Book(title="Mostly Harmless")

>>> # This assignment will consult the router, and set mh onto
>>> # the same database as the author object
>>> mh.author = dna

>>> # This save will force the 'mh' instance onto the primary database...
>>> mh.save()

>>> # ... but if we re-retrieve the object, it will come back on a replica
>>> mh = Book.objects.get(title="Mostly Harmless")

Sainmhínigh an sampla seo ródaire chun idirghníomhaíocht a láimhseáil le samhlacha ón aip auth, agus ródairí eile chun idirghníomhú le gach aip eile a láimhseáil. Má d'fhág tú do bhunachar sonraí default folamh agus mura dteastaíonn uait ródaire bunachar sonraí catch-all a shainiú chun gach aip nach sonraítear ar mhalairt a láimhseáil, ní mór do ródairí ainmneacha gach aip a láimhseáil in:setting: INSTALLED_APPS sula ndéanann tú imirce. Féach:ref: contrib_app_multiple_databases le haghaidh faisnéise faoi apps contrib nach mór a bheith le chéile i mbunachar sonraí amháin.

Bunachar sonraí a roghnú de láimh

Soláthraíonn Django API freisin a ligeann duit smacht iomlán a choinneáil ar úsáid bunachar sonraí i do chód. Glacfaidh leithdháileadh bunachar sonraí sonraithe de láimh tosaíocht ar bhunachar sonraí a leithdháiltear

Bunachar sonraí a roghnú de láimh le haghaidh QuerySet

Is féidir leat an bunachar sonraí do QuerySet` a roghnú ag pointe ar bith sa slabhra QuerySet. Glaoigh ar using () ``ar an `QuerySet chun QuerySet eile a fháil a úsáideann an bunachar sonraí sonraithe.

Tógann ``using () ``argóint amháin: ainm an bhunachar sonraí ar mhaith leat an cheist a reáchtáil. Mar shampla:

Python console
>>> # This will run on the 'default' database.
>>> Author.objects.all()

>>> # So will this.
>>> Author.objects.using("default")

>>> # This will run on the 'other' database.
>>> Author.objects.using("other")

Bunachar sonraí a roghnú le haghaidh ``save () ``

Úsáid an eochairfhocal using le `Model.save () ``chun a shonrú ar cén bunachar sonraí ba chóir na sonraí a shábháil.

Mar shampla, chun réad a shábháil chuig an mbunachar sonraí legacy_users, d'úsáideann tú seo:

Python console
>>> my_object.save(using="legacy_users")

Mura sonraíonn tú úsáid ``, sábhálfaidh an modh ``save () isteach sa bhunachar sonraí réamhshocraithe arna leithdháileadh ag na ródairí.

Ag bogadh réad ó bhunachar sonraí amháin go ceann eile

Má shábháil tú sampla chuig bunachar sonraí amháin, b'fhéidir go mbeadh sé mealltach ``save (using =...) ``a úsáid mar bhealach chun an sampla a aistriú chuig bunachar sonraí nua. Mar sin féin, mura nglacann tú céimeanna iomchuí, d'fhéadfadh roinnt iarmhairtí gan choinne a bheith aige seo.

Smaoinigh ar an sampla seo a leanas:

Python console
>>> p = Person(name="Fred")
>>> p.save(using="first")  # (statement 1)
>>> p.save(using="second")  # (statement 2)

I ráiteas 1, sábhálfar réad nua `Person chuig an mbunachar sonraí chéad. Ag an am seo, níl eochair phríomhúil ag p`, mar sin eisíonn Django ráiteas INSERT SQL. Cruthaíonn sé seo eochair phríomhúil, agus sannann Django an príomh-eochair sin do p`.

Nuair a tharlaíonn an sábháil i ráiteas 2, tá príomhluach ag p` cheana féin, agus déanfaidh Django iarracht an eochair phríomhúil sin a úsáid ar an mbunachar sonraí nua. Mura bhfuil an príomhluach in úsáid sa bhunachar sonraí ``dara ``, ansin ní bheidh aon fhadhbanna agat - cóipeálfar an réad chuig an mbunachar sonraí nua.

Mar sin féin, má tá príomh-eochair p` in úsáid cheana féin ar an mbunachar sonraí dara ``, cuirfear an réad atá ann cheana sa bhunachar sonraí ``soicin` nuair a shábháiltear `p.

Is féidir leat é seo a sheachaint ar dhá bhealach. Ar dtús, is féidir leat eochair phríomhúil an cháis a ghlanadh. Mura bhfuil aon phríomh-eochair ag réad, déileálfaidh Django leis mar réad nua, ag seachaint aon chaillteanas sonraí ar an mbunachar sonraí ``dara ``:

Python console
>>> p = Person(name="Fred")
>>> p.save(using="first")
>>> p.pk = None  # Clear the primary key.
>>> p.save(using="second")  # Write a completely new object.

Is é an dara rogha ná an rogha force_insert a úsáid chun save () ``chun a chinntiú go ndéanann Django SQL ``INSERT:

Python console
>>> p = Person(name="Fred")
>>> p.save(using="first")
>>> p.save(using="second", force_insert=True)

Cinnteoidh sé seo go mbeidh an príomh-eochair chéanna ag an duine darb ainm ``Fred` ar an dá bhunachar sonraí. Má tá an príomh-eochair sin in úsáid cheana féin nuair a dhéanann tú iarracht sábháil ar an mbunachar sonraí ``dara ``, ardófar earráid.

Bunachar sonraí a roghnú le scriosadh as

De réir réamhshocraithe, cuirfear glao chun réad atá ann cheana a scriosadh ar an mbunachar sonraí céanna a úsáideadh chun an réad a aisghabháil sa chéad áit:

Python console
>>> u = User.objects.using("legacy_users").get(username="fred")
>>> u.delete()  # will delete from the `legacy_users` database

Chun an bunachar sonraí as a scriosfar samhail a shonrú, cuir argóint eochairfhocal úsáid ``chuig an modh ``Model.delete (). Oibríonn an argóint seo díreach cosúil leis an argóint eochairfhocal `úsáid ``chun `save ().

Mar shampla, má tá tú ag aistriú úsáideora ón mbunachar sonraí legacy_users chuig an mbunachar sonraí ``new_users`, d'fhéadfá na horduithe seo a úsáid:

Python console
>>> user_obj.save(using="new_users")
>>> user_obj.delete(using="legacy_users")

Bainisteoirí a úsáid le bunachair sonraí il

Úsáid an modh `db_manager () `ar bhainisteoirí chun rochtain a thabhairt do bhainisteoirí ar bhunachar sonraí neamh-réamhshocraithe.

Mar shampla, abair go bhfuil modh bainisteora saincheaptha agat a théann i dteagmháil leis an mbunachar sonraí - User.Objects.create_user () ``. Toisc gur modh bainisteora é `create_user () ``, ní modh ``QuerySet, ní féidir leat User.Objects.using ('new_users') .create_user () a dhéanamh. (Níl an modh create_user () `ar fáil ach ar ``User.Objects`, an bainisteoir, ní ar rudaí ``QuerySet` a dhíorthaítear ón mbainisteoir.) Is é an réiteach ná ``db_manager () ``a úsáid, mar seo:

Code
User.objects.db_manager("new_users").create_user(...)

Filleann ``db_manager () ``cóip den bhainisteoir atá ceangailte leis an mbunachar sonraí a shonraíonn tú.

Ag baint úsáide as ``get_queryset () ``le bunachair sonraí iolracha

Má tá tú ag cur get_queryset () ``ar do bhainisteoir, déan cinnte glaoch ar an modh ar an tuismitheoir (ag baint úsáide as ``super ()) nó déan láimhseáil chuí an tréith _db ar an mbainisteoir (sreang ina bhfuil ainm an bhunachar sonraí le húsáid).

Mar shampla, más mian leat rang saincheaptha QuerySet a thabhairt ar ais ón modh get_queryset, d'fhéadfá seo a dhéanamh:

Code
class MyManager(models.Manager):
    def get_queryset(self):
        qs = CustomQuerySet(self.model)
        if self._db is not None:
            qs = qs.using(self._db)
        return qs

Bunachair sonraí iolracha a nochtadh i gcomhéadan riaracháin D

Níl aon tacaíocht shoiléir ag riarachán Django do iliomad bunachair sonraí. Más mian leat comhéadan riaracháin a sholáthar do mhúnla ar bhunachar sonraí seachas an ceann a shonraíonn do slabhra ródaire, beidh ort ranganna saincheap:class: ~django.contrib.admin.modelAdmin a scríobh a threoróidh an riarachán bunachar sonraí sonrach a úsáid le haghaidh ábhar.

Tá na modhanna seo a leanas ag rudaí ModelAdmin a éilíonn saincheaptha le haghaidh tacaíochta ilbhunachar sonraí:

Code
class MultiDBModelAdmin(admin.ModelAdmin):
    # A handy constant for the name of the alternate database.
    using = "other"

    def save_model(self, request, obj, form, change):
        # Tell Django to save objects to the 'other' database.
        obj.save(using=self.using)

    def delete_model(self, request, obj):
        # Tell Django to delete objects from the 'other' database
        obj.delete(using=self.using)

    def get_queryset(self, request):
        # Tell Django to look for objects on the 'other' database.
        return super().get_queryset(request).using(self.using)

    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        # Tell Django to populate ForeignKey widgets using a query
        # on the 'other' database.
        return super().formfield_for_foreignkey(
            db_field, request, using=self.using, **kwargs
        )

    def formfield_for_manytomany(self, db_field, request, **kwargs):
        # Tell Django to populate ManyToMany widgets using a query
        # on the 'other' database.
        return super().formfield_for_manytomany(
            db_field, request, using=self.using, **kwargs
        )

Cuireann an cur i bhfeidhm a chuirtear ar fáil anseo straitéis ilbhunachar sonraí i bhfeidhm ina ndéantar gach rud de chineál ar leith a stóráil ar bhunachar sonraí ar leith (m.sh., tá gach rud Úsáideora ``sa bhunachar sonraí ``eile). Má tá do úsáid a bhaineann le bunachair sonraí iolracha níos casta, beidh ar do ModelAdmin` an straitéis sin a léiriú.

InlineModelAdmin objects can be handled in a similar fashion. They require three customized methods:

Code
class MultiDBTabularInline(admin.TabularInline):
    using = "other"

    def get_queryset(self, request):
        # Tell Django to look for inline objects on the 'other' database.
        return super().get_queryset(request).using(self.using)

    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        # Tell Django to populate ForeignKey widgets using a query
        # on the 'other' database.
        return super().formfield_for_foreignkey(
            db_field, request, using=self.using, **kwargs
        )

    def formfield_for_manytomany(self, db_field, request, **kwargs):
        # Tell Django to populate ManyToMany widgets using a query
        # on the 'other' database.
        return super().formfield_for_manytomany(
            db_field, request, using=self.using, **kwargs
        )

Nuair a bheidh do shainmhínithe riaracháin samhail scríofa agat, is féidir iad a chlárú le haon shampla Riarachán:

Code
from django.contrib import admin
from myapp.models import Author, Book, Publisher

# Import our custom ModelAdmin and TabularInline from where they're defined.
from myproject.admin import MultiDBModelAdmin, MultiDBTabularInline


# Specialize the multi-db admin objects for use with specific models.
class BookInline(MultiDBTabularInline):
    model = Book


class PublisherAdmin(MultiDBModelAdmin):
    inlines = [BookInline]


admin.site.register(Author, MultiDBModelAdmin)
admin.site.register(Publisher, PublisherAdmin)

othersite = admin.AdminSite("othersite")
othersite.register(Publisher, MultiDBModelAdmin)

Bunaíonn an sampla seo dhá shuíomh riaracháin. Ar an gcéad láithreán, nochtar na rudaí Údar agus Foilsitheoir`; tá inlíne táblaí ag rudaí ``Foilsitheora ``a thaispeánann leabhair arna fhoilsiú ag an bhfoilsitheoir sin. Nochtann an dara suíomh ach foilsitheoirí, gan na línte.

Cúrsaí amh a úsáid le bunachair sonraí iolracha

Má tá níos mó ná bunachar sonraí amháin á úsáid agat is féidir leat django.db.connections a úsáid chun an nasc (agus an cúrsóir) a fháil le haghaidh bunachar sonraí ar leith. Is réad cosúil le foclóir é django.db.connections a ligeann duit nasc ar leith a aisghabháil ag baint úsáide as a ainm:

Code
from django.db import connections

with connections["my_db_alias"].cursor() as cursor:
    ...

Teorainneacha ar bhunachar sonraí

Caidreamh trasbhunachar sonraí

Faoi láthair ní sholáthraíonn Django aon tacaíocht d'eochair eachtracha nó caidrimh go leor a chuimsíonn bunachair sonraí iolracha. Má d'úsáid tú ródaire chun samhlacha a dheighilt chuig bunachair sonraí éagsúla, caithfidh aon eochair eachtrach agus caidrimh go leor a shainmhíníonn na samhlacha sin a bheith inmheánach le bunachar sonraí amháin.

Tá sé seo mar gheall ar shláine tagartha. D'fhonn caidreamh idir dhá réad a choinneáil, ní mór go mbeadh a fhios ag Django go bhfuil príomh-eochair an réada gaolmhara bailí. Má stóráiltear an príomh-eochair ar bhunachar sonraí ar leithligh, ní féidir bailíocht eochair phríomhúil a mheas go héasca.

Má tá Postgres, SQLite, Oracle, nó MySQL á úsáid agat le InnoDB, cuirtear é seo i bhfeidhm ag leibhéal sláine an bhunachar sonraí - cosc ar phríomhshrianta ar leibhéal bunachar sonraí caidrimh nach féidir a bhailíochtú a chruthú.

Mar sin féin, má tá MySQL á úsáid agat le táblaí MyISAM, níl aon sláine tagartha forfheidhmithe ann; mar thoradh air sin, b'fhéidir go mbeidh tú in ann eochracha eachtracha trasbhunachar sonraí 'bréige' a dhéanamh. Mar sin féin, ní thacaíonn Django leis an gcumraíocht seo go hoifigiúil.

Iompar aipeanna contrib

Cuimsíonn roinnt aipeanna contrib samhlacha, agus braitheann roinnt aipeanna ar dhaoine eile. Ós rud é go bhfuil caidrimh tras-bhunachar sonraí dodhéanta, cruthaíonn sé seo roinnt srianta ar an gcaoi ar féidir leat na samhlacha seo

  • is féidir gach ceann de ContentTypes.ContentType`, Sessions.Session` agus Sites.Site a stóráil in aon bhunachar sonraí, mar gheall ar ródaire oiriúnach.

  • Tá samhlacha auth - Úsáideor, Grúpa` agus Cead - nasctha le chéile agus nasctha le ContentType, mar sin ní mór iad a stóráil sa bhunachar sonraí céanna le ContentType`.

  • Braitheann admin ``ar `auth, mar sin caithfidh a mhúnlaí a bheith sa bhunachar sonraí céanna le auth.

  • Braitheann flatpages agus atreoruithe ``ar `suíomhanna, mar sin caithfidh a gcuid samhlacha a bheith sa bhunachar sonraí céanna le ``suíomhanna ``.

Ina theannta sin, cruthaítear roinnt rudaí go huathoibríoch díreach tar éis: cruthaíonn migrate tábla chun iad a choinneáil i mbunachar sonraí:

  • réamhshocraithe ``Suíomh ``,

  • “cineál ábhair” do gach samhail (lena n-áirítear iad siúd nach stóráiltear sa bhunachar sonraí sin),

  • na Ceadúna` do gach samhail (lena n-áirítear iad siúd nach stóráiltear sa bhunachar sonraí sin).

Maidir le socruithe coitianta le bunachair sonraí iolracha, níl sé úsáideach na rudaí seo a bheith i níos mó ná bunachar sonraí amháin. I measc na socruithe coitianta tá bunúsche/macasamhail agus nascadh le bunachair sonraí Dá bhrí sin, moltar a scríobh a:ref: `ródaire bunachar sonraí <topics-db-multi-db-routing>`a cheadaíonn na trí mhúnla seo a shioncrónú le bunachar sonraí amháin. Úsáid an cur chuige céanna le haghaidh aipeanna contrib agus tríú páirtí nach dteastaíonn a dtáblaí uathu i iliomad bunachar

View as Markdown Edit this page on GitHub Official version