RelatedManager
¶A "related manager" is a manager used in a one-to-many or many-to-many related context. This happens in two cases:
"other side" dari sebuah hubungan ForeignKey
. Yaitu:
from django.db import models
class Reporter(models.Model):
# ...
pass
class Article(models.Model):
reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)
Dalam contoh diatas, metode-metode dibawah akan tersedia pada pengelola reporter.article_set
.
Kedua sisi dari hubungan ManyToManyField
:
class Topping(models.Model):
# ...
pass
class Pizza(models.Model):
toppings = models.ManyToManyField(Topping)
Dalam contoh ini, metode-metode dibawah akan tersedia kedua pada topping.pizza_set
dan pada pizza.toppings
.
add
(*objs, bulk=True)¶Menambahkan obyek model ditentukan ke kumpulan obyek terkait.
Contoh:
>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.add(e) # Associates Entry e with Blog b.
Dalam contoh diatas, dalam kasus hubungan ForeignKey
, QuerySet.update()
digunakan untuk melakukan pembaharuan. Ini membutuhkan obyek-obyek untuk sudah disimpan.
Anda dapat menggunakan argumen bulk=False
daripada memiliki pengelola terkait melakukan pembaharuan dengan memanggil e.save()
.
Using add()
with a many-to-many relationship, however, will not
call any save()
methods (the bulk
argument doesn't exist), but
rather create the relationships using QuerySet.bulk_create()
. If you need to execute
some custom logic when a relationship is created, listen to the
m2m_changed
signal, which will
trigger pre_add
and post_add
actions.
Menggunakan ada()
pada hubungan yang sudah ada tidak akan menggandakan hubungan, tetapi itu akan masih memicu sinyal.
create
(**kwargs)¶Membuat sebuah obyek baru, menyimpan itu dan menaruh itu dalam kumpulan obyek terkait. Mengembalikan obyek yang baru dibuat:
>>> b = Blog.objects.get(id=1)
>>> e = b.entry_set.create(
... headline='Hello',
... body_text='Hi',
... pub_date=datetime.date(2005, 1, 1)
... )
# No need to call e.save() at this point -- it's already been saved.
Ini adalah setara pada (tetapi lebih sederhana dari):
>>> b = Blog.objects.get(id=1)
>>> e = Entry(
... blog=b,
... headline='Hello',
... body_text='Hi',
... pub_date=datetime.date(2005, 1, 1)
... )
>>> e.save(force_insert=True)
Note that there's no need to specify the keyword argument of the model
that defines the relationship. In the above example, we don't pass the
parameter blog
to create()
. Django figures out that the new
Entry
object's blog
field should be set to b
.
remove
(*objs, bulk=True)¶memindahkan pbyek-obyek model tertentu dari kumpulan obyek terkait:
>>> b = Blog.objects.get(id=1)
>>> e = Entry.objects.get(id=234)
>>> b.entry_set.remove(e) # Disassociates Entry e from Blog b.
Similar to add()
, e.save()
is called in the example above
to perform the update. Using remove()
with a many-to-many
relationship, however, will delete the relationships using
QuerySet.delete()
which
means no model save()
methods are called; listen to the
m2m_changed
signal if you wish to
execute custom code when a relationship is deleted.
For ForeignKey
objects, this method only
exists if null=True
. If the related field can't be set to None
(NULL
), then an object can't be removed from a relation without
being added to another. In the above example, removing e
from
b.entry_set()
is equivalent to doing e.blog = None
, and because
the blog
ForeignKey
doesn't have
null=True
, this is invalid.
For ForeignKey
objects, this method accepts
a bulk
argument to control how to perform the operation.
If True
(the default), QuerySet.update()
is used.
If bulk=False
, the save()
method of each individual model
instance is called instead. This triggers the
pre_save
and
post_save
signals and comes at the
expense of performance.
Untuk hubungan many-to-many, argumen kata kunci bulk
tidak ada.
clear
(bulk=True)¶Memindahkan semua obyek dari kumpulan obyek terkait:
>>> b = Blog.objects.get(id=1)
>>> b.entry_set.clear()
Catat ini tidak menghapus obyek-obyek terkait -- itu hanya memisahkan mereka.
Just like remove()
, clear()
is only available on
ForeignKey
s where null=True
and it also
accepts the bulk
keyword argument.
Untuk hubungan many-to-many, argumen kata kunci bulk
tidak ada.
set
(objs, bulk=True, clear=False)¶Ganti kumpulan dari obyek terkait:
>>> new_list = [obj1, obj2, obj3]
>>> e.related_set.set(new_list)
This method accepts a clear
argument to control how to perform the
operation. If False
(the default), the elements missing from the
new set are removed using remove()
and only the new ones are added.
If clear=True
, the clear()
method is called instead and the
whole set is added at once.
Untuk obyek ForeignKey
, argumen bulk
dilewatkan ke add()
dan remove()
.
Untuk hubungan many-to-many, argumen kata kunci bulk
tidak ada.
Note that since set()
is a compound operation, it is subject to
race conditions. For instance, new objects may be added to the database
in between the call to clear()
and the call to add()
.
Catatan
Note that add()
, create()
, remove()
, clear()
, and
set()
all apply database changes immediately for all types of
related fields. In other words, there is no need to call save()
on either end of the relationship.
Also, if you are using an intermediate model for a many-to-many relationship, then the
add()
, create()
, remove()
, and set()
methods are
disabled.
Jika anda menggunakan prefetch_related()
, metode add()
, remove()
, clear()
, dan set()
memberishkan cache yang terambil.
Mar 30, 2019