---
title: "Acuan obyek terkait"
version: 4.0
locale: id
source: https://docs.djangoproject.com/id/4.0/ref/models/relations/
canonical: https://djangodocs.dev/id/4.0/ref/models/relations/
---
# Acuan obyek terkait

#### `class 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`](/id/4.0/ref/models/fields/#django.db.models.ForeignKey). Yaitu:

  ```
  from django.db import models

  class Blog(models.Model):
      # ...
      pass

  class Entry(models.Model):
      blog = models.ForeignKey(Blog, on_delete=models.CASCADE, null=True)
  ```

  In the above example, the methods below will be available on
  the manager `blog.entry_set`.
- Kedua sisi dari hubungan [`ManyToManyField`](/id/4.0/ref/models/fields/#django.db.models.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, through_defaults=None)`

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`](/id/4.0/ref/models/fields/#django.db.models.ForeignKey), [`QuerySet.update()`](/id/4.0/ref/models/querysets/#django.db.models.query.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()`](/id/4.0/ref/models/querysets/#django.db.models.query.QuerySet.bulk_create). If you need to execute
some custom logic when a relationship is created, listen to the
[`m2m_changed`](/id/4.0/ref/signals/#django.db.models.signals.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.

For many-to-many relationships `add()` accepts either model instances
or field values, normally primary keys, as the `*objs` argument.

Use the `through_defaults` argument to specify values for the new
[intermediate model](/id/4.0/topics/db/models/#intermediary-manytomany) instance(s), if
needed. You can use callables as values in the `through_defaults`
dictionary and they will be evaluated once before creating any
intermediate instance(s).

#### `create(through_defaults=None, **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.
```

This is equivalent to (but simpler than):

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

Use the `through_defaults` argument to specify values for the new
[intermediate model](/id/4.0/topics/db/models/#intermediary-manytomany) instance, if
needed. You can use callables as values in the `through_defaults`
dictionary.

#### `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()`](#django.db.models.fields.related.RelatedManager.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()`](/id/4.0/ref/models/querysets/#django.db.models.query.QuerySet.delete) which
means no model `save()` methods are called; listen to the
[`m2m_changed`](/id/4.0/ref/signals/#django.db.models.signals.m2m_changed) signal if you wish to
execute custom code when a relationship is deleted.

For many-to-many relationships `remove()` accepts either model
instances or field values, normally primary keys, as the `*objs`
argument.

For [`ForeignKey`](/id/4.0/ref/models/fields/#django.db.models.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`](/id/4.0/ref/models/fields/#django.db.models.ForeignKey) doesn't have
`null=True`, this is invalid.

For [`ForeignKey`](/id/4.0/ref/models/fields/#django.db.models.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`](/id/4.0/ref/signals/#django.db.models.signals.pre_save) and
[`post_save`](/id/4.0/ref/signals/#django.db.models.signals.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`](/id/4.0/ref/models/fields/#django.db.models.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, through_defaults=None)`

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`](/id/4.0/ref/models/fields/#django.db.models.ForeignKey), argumen `bulk` dilewatkan ke [`add()`](#django.db.models.fields.related.RelatedManager.add) dan [`remove()`](#django.db.models.fields.related.RelatedManager.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()`.

For many-to-many relationships `set()` accepts a list of either model
instances or field values, normally primary keys, as the `objs`
argument.

Use the `through_defaults` argument to specify values for the new
[intermediate model](/id/4.0/topics/db/models/#intermediary-manytomany) instance(s), if
needed. You can use callables as values in the `through_defaults`
dictionary and they will be evaluated once before creating any
intermediate instance(s).

> **Note**
>
> 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.
>
> Jika anda menggunakan [`prefetch_related()`](/id/4.0/ref/models/querysets/#django.db.models.query.QuerySet.prefetch_related), metode `add()`, `remove()`, `clear()`, dan `set()` memberishkan cache yang terambil.