---
title: "Optimisasi akses basisdata"
version: 2.2
locale: id
source: https://docs.djangoproject.com/id/2.2/topics/db/optimization/
canonical: https://djangodocs.dev/id/2.2/topics/db/optimization/
---
# Optimisasi akses basisdata

Lapisan basisdata Django menyediakan beragam cara membantu pengembang mendapatkan sebagian dari basisdata mereka. DOkumen ini mengumpulkan bersama-sama tautan ke dokumentasi bersangkutan, dan menambah beraagam tip, mengorganisasikan dibawah sejumlah dari kepala yang meringkaskan langkah-langkah diambil ketika berusaha mengoptimalkan penggunaan basisdata anda.

## Profil dahulu

As general programming practice, this goes without saying. Find out [what
queries you are doing and what they are costing you](/id/2.2/faq/models/#faq-see-raw-sql-queries).
Use [`QuerySet.explain()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.explain) to understand how specific `QuerySet`s are
executed by your database. You may also want to use an external project like
[django-debug-toolbar](https://github.com/jazzband/django-debug-toolbar/), or a tool that monitors your database directly.

Ingat bahwa anda mungkin dioptimalkan untuk kecepatan atau memori atau keduanya, tergantung pada persyaraan anda. Terkadang mengoptimalkan untuk satu akan merugikan ke yang lain, tetapi terkadang mereka akan membantu satu sama lain. Juga, pekerjaan itu selesai oleh pengolahan basisdata mungkin tidak mempunyai biaya sama (kepada anda) seperti sama banyak dari pekerjaan selesai dalam pengolahan Python anda. Itu terserah anda memutuskan apa prioritas anda, dimana keseimbangan harus berbohong, dan profil semua dari ini seperti diwajibkan sejak ini akan bergantung pada aplikasi anda dan peladen.

Dengan apapun yang mengikuti, ingat untuk menggambarkan raut muka setelah setiap perubahan untuk memastikan bahwa perubahan adalah menguntungkan, dan keuntungan cukup besar diberikan menurunkan dalam kesiapan kode anda. **Semua** dari saran-saran dibawah datang dengan surat keberatan yang dalam keadaan anda prinsip umum mungkin tidak berlaku, atau mungkin bahkan dibalikkan.

## Gunakan teknik-teknik optimalisasi DB standar

...termasuk:

- [Indexes](https://en.wikipedia.org/wiki/Database_index). This is a number one priority, *after* you have determined from
  profiling what indexes should be added. Use
  [`Meta.indexes`](/id/2.2/ref/models/options/#django.db.models.Options.indexes) or
  [`Field.db_index`](/id/2.2/ref/models/fields/#django.db.models.Field.db_index) to add these from
  Django. Consider adding indexes to fields that you frequently query using
  [`filter()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.filter),
  [`exclude()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.exclude),
  [`order_by()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.order_by), etc. as indexes may help
  to speed up lookups. Note that determining the best indexes is a complex
  database-dependent topic that will depend on your particular application.
  The overhead of maintaining an index may outweigh any gains in query speed.

- Penggunaan sesuai dari jenis-jenis bidang

Kami akan menganggap anda telah melakukan hal-hal tidak jelas diatas. Sisa dari dokumen ini fokus pada bagaimana menggunakan Django dalam seperti itu yang anda tidak melakukan pekerjaan tidak penting. Dokumen ini tidak mengalamatkan teknik-teknik optimalisasi lain yang berlaku ke semua tindakan, seperti general purpose caching 1.

## Memahami `QuerySet`

Memahami [QuerySets](/id/2.2/ref/models/querysets/) adalah vital untuk mendapatkan penampilan baik dengan kode sederhana. Khususnya:

### Memahami penilaian `QuerySet`

Untuk menghindari masalah penampilan, sangatlah penting memahami:

- itu [QuerySets malas](/id/2.2/topics/db/queries/#querysets-are-lazy).
- ketika [mereka dinilai](/id/2.2/ref/models/querysets/#when-querysets-are-evaluated).
- bagaimana [data ditahan dalam memori](/id/2.2/topics/db/queries/#caching-and-querysets).

### Memahami atribut tembolok

Seperti menyimpan sementara keseluruhan `QuerySet`, ada penyimpanan sementara dari hasil atribut pada obyek ORM. Secara umum, atribut-atribut tidak dapat dipanggil akan disimpan sementara. Sebagai contoh, menganggap example Weblog models 1:

```
>>> entry = Entry.objects.get(id=1)
>>> entry.blog   # Blog object is retrieved at this point
>>> entry.blog   # cached version, no DB access
```

Tetapi secara umum, atribut callable menyebabkan pencarian DB setiap waktu:

```
>>> entry = Entry.objects.get(id=1)
>>> entry.authors.all()   # query performed
>>> entry.authors.all()   # query performed again
```

Hati-hati ketika membaca kode cetakan - sistem cetakan tidak mengizinkan penggunaan tanda kurun, tetapi akan memanggil callable secara otomatis, memnyembunyikan perbedaan diatas.

Berhati-hatilan dengan sifat penyesuaian anda sendiri - itu terserah anda menerapkan cache ketika dibutuhkan, sebagai contoh menggunakan penghias [`cached_property`](/id/2.2/ref/utils/#django.utils.functional.cached_property).

### Gunakan etiket cetakan `with`

Untuk menggunakan perilaku cache dari `QuerySet`, anda mungkin butuh menggunakan etiket cetakan  [`with`](/id/2.2/ref/templates/builtins/#std-templatetag-with).

### Gunakan `iterator()`

Ketika anda mempunyai banyak obyek, perilaku cache dari `QuerySet` dapat menyebabkan sejumlah besar memori digunakan. Dalam kasus ini, [`iterator()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.iterator) mungkin membantu.

### Gunakan `explain()`

[`QuerySet.explain()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.explain) gives you detailed information about how the database
executes a query, including indexes and joins that are used. These details may
help you find queries that could be rewritten more efficiently, or identify
indexes that could be added to improve performance.

## Lakukan pekerjaan basisdata di basisdata daripada di Python

Sebagai contoh:

- Pada paling tingkat dasar, gunakan [filter and exclude](/id/2.2/ref/models/querysets/#queryset-api) melakukan penyaringan di basisdata
- Gunakan [`F expressions`](/id/2.2/ref/models/expressions/#django.db.models.F) untukmenyaring berdasarkan pada bidang-bidang lain dalam model sama.
- Gunakan [annotate to do aggregation in the database](/id/2.2/topics/db/aggregation/).

Jika ini tidak cukup membangkitkan SQL yang anda butuhkan:

### Gunakan `RawSQL`

Sedikit ringan tetapi metode lebih kuat adalah pernyataan [`RawSQL`](/id/2.2/ref/models/expressions/#django.db.models.expressions.RawSQL), yangmengizinkan beberapa SQL secara jelas ditambahkan ke permintaan. Jika itu masih tidak cukup kuat:

### Gunakan SQL mentah

Tulis custom SQL to retrieve data or populate models 1 anda sendiri. Gunakan `django.db.connection.queries` untuk menemukan apa yang Django sedang tulis untuk anda dan mulai dari sana.

## Mengambil obyek tersendiri menggukan sebuah unik, kolom indeks

Ada dua alasan untuk menggunakan kolom dengan [`unique`](/id/2.2/ref/models/fields/#django.db.models.Field.unique) atau [`db_index`](/id/2.2/ref/models/fields/#django.db.models.Field.db_index) ketika menggunakan [`get()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.get) untuk mengambil obyek tersendiri. Pertama, permintaan akan lebih cepat karena indeks basisdata pokok. Juga, permintaan dapat berjalan lebih lambat jika banyak obyek mencocokan pencarian; memiliki batasan unik pada kolom menjamin ini tidak pernah terjadi.

Jadi menggunakan [example Weblog models](/id/2.2/topics/db/queries/#queryset-model-example):

```
>>> entry = Entry.objects.get(id=10)
```

akan lebih cepat daripada:

```
>>> entry = Entry.objects.get(headline="News Item Title")
```

karena `id` diindeks oleh basisdata dan dijamin menjadi unik.

Melakukan berikut berpotensi sangat lambat:

```
>>> entry = Entry.objects.get(headline__startswith="News")
```

Pertama-tama, `headline` tidak diindeks, yang akan membuat pengambilan pokok basisdata lebih lambat.

Kedua, pencarian tidak menjamin hanya satu obyek akan dikembalikan. Jika permintaan cocok lebih dari satu obyek, itu akan mengambil dan memindahkan semua dari mereka dari basisdata. Hukuman ini dapat besar jika ratusan atau ribuan dari rekaman dikembalikan. Hukuman akan digabungkan jika basisdata berada pada peladen berbeda, dimana overhead jaringan dan latensi memainkan faktor.

## Mengambil semuanya sekaligus jika anda mengetahui anda akan membutuhkannya

Mengenai basisdata beberapa kali untuk bagian-bagian berbeda dari 'set' tunggal data yang anda akan butuh semua bagian, secara umum, kurang efisien dari mengambil itu semua dalam satu permintaan. Ini khususnya penting jika anda mempunyai sebuah permintaan yang dijalankan dalam putaran, dan dapat karena itu berakhir melakukan banyak permintaan basisdata, ketika hanya satu dibutuhkan. Jadi:

### Gunakan `QuerySet.select_related()` dan `prefetch_related()`

Memahami [`select_related()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.select_related) dan [`prefetch_related()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.prefetch_related) sepenuhnya, dan menggunakan mereka:

- dalam managers and default managers 1 dimana sesuai. Waspada ketika pengelola anda sedang dan tidak digunakan; terkadang ini rumit jadi jangan membuat prasangka.
- dalam melihat kode atau lapisan-lapisan lain, kemungkinan membuat menggunaan dari [`prefetch_related_objects()`](/id/2.2/ref/models/querysets/#django.db.models.prefetch_related_objects) ketika dibutuhkan.

## Jangan mengambil hal yang tidak anda butuhkan

### Gunakan `QuerySet.values()` dan `values_list()`

Ketika anda hanya ingin nilai-nilai `dict` atau `list`, dan tidak butuh obyek model ORM, buat penggunaan sesuai dari [`values()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.values). Ini dapat berguna untuk mengganti obyek model dalam kode cetakan - selama dictionary anda sokong mempuyai atribut sama seperti itu digunakan dalam cetakan, anda baik-baik saja.

### Gunakan `QuerySet.defer()` dan `only()`

Gunakan [`defer()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.defer) dan [`only()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.only) jika ada kolom basisdata anda ketahui bahwa anda tidak butuh (atau tidak butuh dalam kebanyakan kasus) untuk menghindari memuatkan mereka. Catat bahwa jika anda *melakukan* menggunakan mereka, ORM akan harus pergi dan mendapatkan mereka dalam permintaan terpisah, membuat ini pesimis jika anda menggunakan itu secara tidak benar.

Don't be too aggressive in deferring fields without profiling as the database
has to read most of the non-text, non-VARCHAR data from the disk for a single
row in the results, even if it ends up only using a few columns. The
`defer()` and `only()` methods are most useful when you can avoid loading a
lot of text data or for fields that might take a lot of processing to convert
back to Python. As always, profile first, then optimize.

### Gunakan `QuerySet.count()`

..jika anda hanya ingin menghitung, daripada melakukan `len(queryset)`.

### Gunakan `QuerySet.exists()`

...jika anda hanya ingin menemukan jika setidaknya satu hasil ada, daripada `if queryset`.

Tetapi:

### Jangan berlebihan `count()` dan `exists()`

Jika anda akan butuh data lain dari QuerySet, cukup nilai itu.

Sebagai contoh, menganggap sebuah model Email yang mempunyai atribut `body` dan hubungan many-to-many pada User, kode cetakan berikut adalah optimal:

```html+django
{% if display_inbox %}
  {% with emails=user.emails.all %}
    {% if emails %}
      <p>You have {{ emails|length }} email(s)</p>
      {% for email in emails %}
        <p>{{ email.body }}</p>
      {% endfor %}
    {% else %}
      <p>No messages today.</p>
    {% endif %}
  {% endwith %}
{% endif %}
```

DIa optimal karena:

1. Sejak QuerySet adalah lazy, ini tidak melakukan permintaan basisdata jika 'display\_inbox' adalah False.
2. Penggunaan [`with`](/id/2.2/ref/templates/builtins/#std-templatetag-with) berarti bahwa kami menyimpan `user.emails.all`  dalam sebuah variabel untuk penggunaan akhir, mengizinkan cache itu untuk digunakan-kembali.
3. Baris `{% if emails %}` menyebabkan `QuerySet.__bool__()` dipanggil, yang menyebabkan permintaan `user.emails.all()` dijalankan pada basisdata, dan setidaknya baris pertama dirubah menjadi obyek ORM. Jika tidak ada hasil apapun, itu akan mengembalikan False, sebaliknya True.
4. Penggunaan `{{ emails|length }}` memanggil `QuerySet.__len__()`, mengisi sisa dari cache tanpa melakukan permintaan lain.
5. Putaran [`for`](/id/2.2/ref/templates/builtins/#std-templatetag-for) berulang terhadap cache sudah diisi.

Dalam jumlah, kode ini melakukan baik satu atau nol permintaan basisdata. Satu-satunya optimalisasi kesengajaan dilakukan adalah menggunakan etiket [`with`](/id/2.2/ref/templates/builtins/#std-templatetag-with). Menggunakan `QuerySet.exists()` atau `QuerySet.count()` pada titik apapun akan menyebabkan tambahan permintaan.

### Gunakan `QuerySet.update()` dan `delete()`

Daripada mengambil memuat obyek, setel beberapa nilai, dan simpan mereka masing-masing, gunakan pernyataan SQL UPDATE dalam jumlah besar, melalui QuerySet.update() 1. Demikian pula, lakukan bulk deletes 2 dimana memungkinkan.

Catat, bagaimanapun, metode pembaharuan jumlah besar ini tidak dapat memanggil metode `save()` atau `delete()` dari masing-masing instance, yang berarti bahwa perilaku penyesuaian apapun anda telah tambahkan untuk metode-metode ini tidak akan dijalankan, termasuk apapun didorong dari obyek basisdata biasa signals 1.

### Menggunakan nilai foreign key secara langsung

Jika anda hanya butuh nilai foreign key, gunakan nilai foreign key yang sudah pada obyek anda telah dapatkan, daripada mendapatkan keseluruhan obyek terkait dan mengambil primary key nya, yaitu. lakukan:

```
entry.blog_id
```

dari pada:

```
entry.blog.id
```

### Jangan urutkan hasil jika anda tidak peduli

Pengurutan tidak bebas; setiap bidang yang diurutkan adalah sebuah operai basisdata harus dilakukan. Jika sebuah model awal mengurutkan ([`Meta.ordering`](/id/2.2/ref/models/options/#django.db.models.Options.ordering)) dan anda tidak membutuhkannya, pindahkan dia pada `QuerySet` dengan memanggil [`order_by()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.order_by) dengan tidak ada parameter.

Menambahkan indeks ke basisdata anda mungkin membantu meningkatkan penampilan pengurutan.

## Use bulk methods

Use bulk methods to reduce the number of SQL statements.

### Create in bulk

Ketika membuat obyek-obyek, dimana memungkinkan, gunakan metode [`bulk_create()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.bulk_create) untuk mengurangi sejumlah permintaan SQL. Sebagai contoh:

```
Entry.objects.bulk_create([
    Entry(headline='This is a test'),
    Entry(headline='This is only a test'),
])
```

...adalah lebih baik untuk:

```
Entry.objects.create(headline='This is a test')
Entry.objects.create(headline='This is only a test')
```

Catat bahwa ada angka dari [`caveats to this method`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.bulk_create), jadi pastikan dia sesuai untuk kasus digunakan anda.

### Update in bulk

> **New in Django 2.2**

When updating objects, where possible, use the
[`bulk_update()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.bulk_update) method to reduce the
number of SQL queries. Given a list or queryset of objects:

```
entries = Entry.objects.bulk_create([
    Entry(headline='This is a test'),
    Entry(headline='This is only a test'),
])
```

The following example:

```
entries[0].headline = 'This is not a test'
entries[1].headline = 'This is no longer a test'
Entry.objects.bulk_update(entries, ['headline'])
```

...adalah lebih baik untuk:

```
entries[0].headline = 'This is not a test'
entries.save()
entries[1].headline = 'This is no longer a test'
entries.save()
```

Note that there are a number of [`caveats to this method`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.bulk_update), so make sure it's appropriate
for your use case.

### Masuk dalam bulk

When inserting objects into [`ManyToManyFields`](/id/2.2/ref/models/fields/#django.db.models.ManyToManyField), use
[`add()`](/id/2.2/ref/models/relations/#django.db.models.fields.related.RelatedManager.add) with multiple
objects to reduce the number of SQL queries. For example:

```
my_band.members.add(me, my_friend)
```

...adalah lebih baik untuk:

```
my_band.members.add(me)
my_band.members.add(my_friend)
```

...dimana `Bands` dan `Artists` mempunyai hubungan many-to-many.

When inserting different pairs of objects into
[`ManyToManyField`](/id/2.2/ref/models/fields/#django.db.models.ManyToManyField) or when the custom
[`through`](/id/2.2/ref/models/fields/#django.db.models.ManyToManyField.through) table is defined, use
[`bulk_create()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.bulk_create) method to reduce the
number of SQL queries. For example:

```
PizzaToppingRelationship = Pizza.toppings.through
PizzaToppingRelationship.objects.bulk_create([
    PizzaToppingRelationship(pizza=my_pizza, topping=pepperoni),
    PizzaToppingRelationship(pizza=your_pizza, topping=pepperoni),
    PizzaToppingRelationship(pizza=your_pizza, topping=mushroom),
], ignore_conflicts=True)
```

...adalah lebih baik untuk:

```
my_pizza.toppings.add(pepperoni)
your_pizza.toppings.add(pepperoni, mushroom)
```

...where `Pizza` and `Topping` have a many-to-many relationship. Note that
there are a number of [`caveats to this method`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.bulk_create), so make sure it's appropriate
for your use case.

### Remove in bulk

When removing objects from [`ManyToManyFields`](/id/2.2/ref/models/fields/#django.db.models.ManyToManyField), use
[`remove()`](/id/2.2/ref/models/relations/#django.db.models.fields.related.RelatedManager.remove) with multiple
objects to reduce the number of SQL queries. For example:

```
my_band.members.remove(me, my_friend)
```

...adalah lebih baik untuk:

```
my_band.members.remove(me)
my_band.members.remove(my_friend)
```

...dimana `Bands` dan `Artists` mempunyai hubungan many-to-many.

When removing different pairs of objects from [`ManyToManyFields`](/id/2.2/ref/models/fields/#django.db.models.ManyToManyField), use
[`delete()`](/id/2.2/ref/models/querysets/#django.db.models.query.QuerySet.delete) on a
[`Q`](/id/2.2/ref/models/querysets/#django.db.models.Q) expression with multiple
[`through`](/id/2.2/ref/models/fields/#django.db.models.ManyToManyField.through)  model instances to reduce
the number of SQL queries. For example:

```
from django.db.models import Q
PizzaToppingRelationship = Pizza.toppings.through
PizzaToppingRelationship.objects.filter(
    Q(pizza=my_pizza, topping=pepperoni) |
    Q(pizza=your_pizza, topping=pepperoni) |
    Q(pizza=your_pizza, topping=mushroom)
).delete()
```

...adalah lebih baik untuk:

```
my_pizza.toppings.remove(pepperoni)
your_pizza.toppings.remove(pepperoni, mushroom)
```

...where `Pizza` and `Topping` have a many-to-many relationship.