Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memindai tabel di DynamoDB
Operasi `Scan` di Amazon DynamoDB membaca setiap item dalam tabel atau indeks sekunder. Secara default, operasi `Scan` mengembalikan semua atribut data untuk setiap item dalam tabel atau indeks. Anda dapat menggunakan parameter `ProjectionExpression` sehingga `Scan` hanya mengembalikan beberapa atribut, bukan semuanya.
`Scan` selalu mengembalikan set hasil. Jika tidak ditemukan item yang cocok, set hasil kosong.
Permintaan `Scan` tunggal dapat mengambil data maksimum 1 MB. Atau, DynamoDB dapat menerapkan ekspresi filter pada data ini, mengerucutkan hasil sebelum dikembalikan ke pengguna.
**Topics**
+ [Ekspresi filter untuk pemindaian](#Scan.FilterExpression)
+ [Membatasi jumlah item dalam set hasil](#Scan.Limit)
+ [Memberi nomor halaman hasil](#Scan.Pagination)
+ [Menghitung item dalam hasil](#Scan.Count)
+ [Unit kapasitas dikonsumsi oleh pemindaian](#Scan.CapacityUnits)
+ [Konsistensi baca untuk kueri](#Scan.ReadConsistency)
+ [Pemindaian paralel](#Scan.ParallelScan)
## Ekspresi filter untuk pemindaian
Jika Anda perlu menyempurnakan hasil `Scan` lebih lanjut, Anda dapat memberikan ekspresi filter secara opsional. *Ekspresi filter* menentukan item mana dalam hasil `Scan` yang harus dikembalikan kepada Anda. Semua hasil lainnya dibuang.
Filter ekspresi diterapkan setelah `Scan` selesai, tetapi sebelum hasilnya dikembalikan. Oleh karena itu, `Scan` menggunakan jumlah kapasitas baca yang sama, terlepas dari apakah ada ekspresi filter.
Operasi `Scan` dapat mengambil data maksimal 1 MB. Batasan ini berlaku sebelum ekspresi filter dievaluasi.
Dengan `Scan`, Anda dapat menentukan atribut apa pun dalam ekspresi filter, termasuk atribut kunci partisi dan kunci urutan.
Sintaks untuk ekspresi filter mirip dengan ekspresi kondisi kunci. Ekspresi filter dapat menggunakan pembanding, fungsi, dan operator logika yang sama sebagai ekspresi kondisi utama. Lihat [Kondisi dan filter ekspresi, operator, dan fungsi di DynamoDB](Expressions.OperatorsAndFunctions.md) untuk informasi selengkapnya tentang operator logika.
**Example**
Contoh berikut AWS Command Line Interface (AWS CLI) memindai `Thread` tabel dan hanya mengembalikan item yang terakhir diposting oleh pengguna tertentu.
```
aws dynamodb scan \
--table-name Thread \
--filter-expression "LastPostedBy = :name" \
--expression-attribute-values '{":name":{"S":"User A"}}'
```
## Membatasi jumlah item dalam set hasil
Operasi `Scan` memungkinkan Anda membatasi jumlah item yang dikembalikan dalam hasil. Untuk melakukannya, tetapkan parameter `Limit` pada jumlah maksimum item yang Anda inginkan untuk dikembalikan operasi `Scan`, sebelum evaluasi ekspresi filter.
Misalnya, anggaplah bahwa Anda melakukan `Scan` pada tabel, dengan nilai `Limit` adalah `6`, dan tanpa ekspresi filter. Hasil `Scan` berisi enam item pertama dari tabel.
Sekarang anggap bahwa Anda menambahkan ekspresi filter ke `Scan`. Dalam kasus ini, DynamoDB menerapkan ekspresi filter untuk enam item yang dikembalikan, membuang item yang tidak cocok. Hasil `Scan` akhir berisi enam item atau lebih sedikit, tergantung jumlah item yang disaring.
## Memberi nomor halaman hasil
DynamoDB *memberi nomor halaman* hasil dari operasi `Scan`. Dengan pemberian nomor halaman, hasil `Scan` dibagi menjadi "halaman" data berukuran 1 MB (atau kurang). Aplikasi bisa memproses halaman pertama hasil, lalu halaman kedua, dan seterusnya.
`Scan` tunggal hanya mengembalikan set hasil yang sesuai dalam batas ukuran 1 MB.
Untuk menentukan apakah terdapat lebih banyak hasil, dan untuk mengambilkan satu halaman sekaligus, aplikasi harus melakukan hal berikut:
1. Periksa hasil `Scan` tingkat rendah:
+ Jika hasilnya berisi elemen `LastEvaluatedKey`, lanjutkan ke langkah 2.
+ Jika *tidak ada* `LastEvaluatedKey` pada hasilnya, tidak ada lagi item yang dapat diambil.
1. Buat permintaan `Scan` baru, dengan parameter yang sama seperti yang sebelumnya. Namun, kali ini, ambil nilai `LastEvaluatedKey` dari langkah 1 dan gunakan sebagai parameter `ExclusiveStartKey` dalam permintaan `Scan` baru.
1. Jalankan permintaan `Scan` baru.
1. Lanjutkan ke langkah 1.
Dengan kata lain, `LastEvaluatedKey` dari respons `Scan` harus digunakan sebagai `ExclusiveStartKey` untuk permintaan `Scan` berikutnya. Jika tidak ada elemen `LastEvaluatedKey` dalam respons `Scan`, Anda telah mengambil halaman hasil akhir. (Tidak adanya `LastEvaluatedKey` adalah satu-satunya cara untuk mengetahui bahwa Anda telah mencapai akhir set hasil.)
Anda dapat menggunakan AWS CLI untuk melihat perilaku ini. AWS CLI Mengirimkan `Scan` permintaan tingkat rendah ke DynamoDB, berulang kali, `LastEvaluatedKey` hingga tidak lagi hadir dalam hasil. Perhatikan AWS CLI contoh berikut yang memindai seluruh `Movies` tabel tetapi hanya mengembalikan film dari genre tertentu.
```
aws dynamodb scan \
--table-name Movies \
--projection-expression "title" \
--filter-expression 'contains(info.genres,:gen)' \
--expression-attribute-values '{":gen":{"S":"Sci-Fi"}}' \
--page-size 100 \
--debug
```
Biasanya, AWS CLI menangani pagination secara otomatis. Namun, dalam contoh ini, AWS CLI `--page-size` parameter membatasi jumlah item per halaman. Parameter `--debug` mencetak informasi tingkat rendah tentang permintaan dan respons.
**catatan**
Hasil pemberian nomor halaman Anda juga akan berbeda berdasarkan parameter input yang Anda lewati.
Menggunakan `aws dynamodb scan --table-name Prices --max-items 1` mengembalikan `NextToken`
Menggunakan `aws dynamodb scan --table-name Prices --limit 1` mengembalikan `LastEvaluatedKey`.
Ketahuilah juga bahwa menggunakan `--starting-token` khususnya membutuhkan nilai `NextToken`.
Jika Anda menjalankan contoh ini, respons pertama dari DynamoDB terlihat serupa dengan yang berikut ini.
```
2017-07-07 12:19:14,389 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":7,"Items":[{"title":{"S":"Monster on the Campus"}},{"title":{"S":"+1"}},
{"title":{"S":"100 Degrees Below Zero"}},{"title":{"S":"About Time"}},{"title":{"S":"After Earth"}},
{"title":{"S":"Age of Dinosaurs"}},{"title":{"S":"Cloudy with a Chance of Meatballs 2"}}],
"LastEvaluatedKey":{"year":{"N":"2013"},"title":{"S":"Curse of Chucky"}},"ScannedCount":100}'
```
`LastEvaluatedKey` dalam responsnya menunjukkan bahwa tidak semua item telah diambil. AWS CLI Kemudian mengeluarkan `Scan` permintaan lain ke DynamoDB. Pola permintaan dan respons ini berlanjut hingga respons akhir.
```
2017-07-07 12:19:17,830 - MainThread - botocore.parsers - DEBUG - Response body:
b'{"Count":1,"Items":[{"title":{"S":"WarGames"}}],"ScannedCount":6}'
```
Tidak adanya `LastEvaluatedKey` menunjukkan bahwa tidak ada lagi item yang dapat diambil.
**catatan**
AWS SDKs Menangani respons DynamoDB tingkat rendah (termasuk ada atau tidak adanya) dan memberikan berbagai `LastEvaluatedKey` abstraksi untuk hasil paginasi. `Scan` Misalnya, antarmuka dokumen SDK untuk Java menyediakan dukungan `java.util.Iterator` sehingga Anda dapat mempelajari hasilnya satu per satu.
Untuk contoh kode dalam berbagai bahasa pemrograman, lihat [Panduan Memulai Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/) dan dokumentasi AWS SDK untuk bahasa Anda.
## Menghitung item dalam hasil
Selain item yang sesuai dengan kriteria Anda, respons `Scan` berisi elemen berikut:
+ `ScannedCount` — Jumlah item yang dievaluasi, sebelum `ScanFilter` diterapkan. Nilai `ScannedCount` yang tinggi dengan sedikit, atau tanpa hasil, `Count` hasil menunjukkan operasi `Scan` yang tidak efisien. Jika Anda tidak menggunakan filter dalam permintaan, `ScannedCount` sama dengan `Count`.
+ `Count` — Jumlah item yang tersisa *setelah* ekspresi filter (jika ada) diterapkan.
**catatan**
Jika Anda tidak menggunakan ekspresi filter, `ScannedCount` dan `Count` memiliki nilai yang sama.
Jika ukuran set hasil `Scan` lebih besar dari 1 MB, `ScannedCount` dan `Count` mewakili hanya jumlah parsial dari total item. Anda harus melakukan beberapa operasi `Scan` untuk mengambil semua hasil (lihat [Memberi nomor halaman hasil](#Scan.Pagination)).
Setiap respons `Scan` berisi `ScannedCount` dan `Count` untuk item yang diproses oleh permintaan `Scan` khusus. Untuk mendapatkan total keseluruhan untuk semua permintaan `Scan`, Anda dapat menyimpan penghitungan `ScannedCount` dan `Count`.
## Unit kapasitas dikonsumsi oleh pemindaian
Anda dapat melakukan `Scan` pada setiap tabel atau indeks sekunder. Operasi `Scan` mengonsumsi unit kapasitas baca, sebagai berikut.
****
| Jika Anda `Scan`... | DynamoDB menggunakan unit kapasitas baca dari... |
| --- | --- |
| Tabel | Kapasitas baca yang ditetapkan tabel. |
| Indeks sekunder global | Kapasitas baca yang ditetapkan indeks. |
| Indeks sekunder lokal | Kapasitas baca yang ditetapkan tabel dasar. |
**catatan**
Akses lintas akun untuk operasi pemindaian indeks sekunder saat ini tidak didukung dengan kebijakan berbasis [sumber daya](access-control-resource-based.md).
Secara default, operasi `Scan` tidak menampilkan data tentang berapa banyak kapasitas baca yang digunakan. Namun, Anda dapat menentukan parameter `ReturnConsumedCapacity` dalam sebuah permintaan `Scan` untuk mendapatkan informasi ini. Berikut ini adalah pengaturan yang valid untuk `ReturnConsumedCapacity`:
+ `NONE` — Tidak ada penggunaan data kapasitas yang ditampilkan. (Ini menjadi opsi default.)
+ `TOTAL` — Respons mencakup jumlah agregat unit kapasitas baca yang digunakan.
+ `INDEXES` — Respons menunjukkan jumlah agregat unit kapasitas baca yang digunakan, beserta dengan kapasitas yang digunakan untuk setiap tabel dan indeks yang diakses.
DynamoDB menghitung jumlah unit kapasitas baca yang dikonsumsi berdasarkan jumlah item dan ukuran item tersebut, bukan pada jumlah data yang dikembalikan ke aplikasi. Dengan alasan ini, jumlah unit kapasitas yang digunakan adalah sama, entah Anda meminta semua atribut (perilaku default) atau hanya beberapa dari atribut tersebut (menggunakan ekspresi proyeksi). Jumlahnya juga sama apakah Anda menggunakan ekspresi filter atau tidak. `Scan`mengkonsumsi unit kapasitas baca minimum untuk melakukan satu pembacaan yang sangat konsisten per detik, atau dua pembacaan yang konsisten per detik untuk item hingga 4 KB. Jika Anda perlu membaca item yang lebih besar dari 4 KB, DynamoDB memerlukan unit permintaan baca tambahan. Tabel kosong dan tabel yang sangat besar yang memiliki jumlah kunci partisi yang jarang mungkin melihat beberapa tambahan yang RCUs dibebankan melebihi jumlah data yang dipindai. Ini mencakup biaya melayani `Scan` permintaan, bahkan jika tidak ada data.
## Konsistensi baca untuk kueri
Operasi `Scan` melakukan bacaan akhir konsisten, secara default. Ini berarti bahwa hasil `Scan` mungkin tidak mencerminkan perubahan karena operasi `PutItem` atau `UpdateItem` baru saja selesai. Untuk informasi selengkapnya, lihat [DynamoDB membaca konsistensi](HowItWorks.ReadConsistency.md).
Jika Anda memerlukan bacaan sangat konsisten, pada saat `Scan` dimulai, atur parameter `ConsistentRead` menjadi `true` dalam permintaan `Scan`. Hal ini memastikan bahwa semua operasi tulis yang diselesaikan sebelum `Scan` dimulai termasuk dalam respons `Scan`.
Mengatur `ConsistentRead` ke `true` dapat berguna dalam skenario pencadangan atau replikasi tabel, dalam hubungannya dengan [DynamoDB Streams](./Streams.html). Anda pertama kali menggunakan `Scan` dengan `ConsistentRead` yang diatur ke true untuk mendapatkan salinan data yang konsisten dalam tabel. Selama `Scan`, DynamoDB Streams mencatat aktivitas tulis tambahan yang terjadi pada tabel. Setelah `Scan` selesai, Anda dapat menerapkan aktivitas tulis dari stream ke table.
**catatan**
Operasi `Scan` dengan `ConsistentRead` yang diatue ke `true` mengonsumsi dua kali lebih banyak unit kapasitas baca dibandingkan dengan meninggalkan `ConsistentRead` pada nilai defaultnya (`false`).
## Pemindaian paralel
Secara default, operasi `Scan` memproses data secara berurutan. Amazon DynamoDB mengembalikan data ke aplikasi dalam kenaikan 1 MB, dan aplikasi melakukan operasi `Scan` tambahan untuk mengambil 1 MB data berikutnya.
Makin besar tabel atau indeks yang dipindai, makin banyak waktu yang diperlukan untuk menyelesaikan `Scan`. Selain itu, `Scan` berurutan mungkin tidak selalu dapat sepenuhnya menggunakan kapasitas throughput baca yang disediakan: Meskipun DynamoDB mendistribusikan data tabel besar ke beberapa partisi fisik, operasi `Scan` hanya dapat membaca satu partisi dalam satu waktu. Karena alasan ini, throughput `Scan` dibatasi oleh throughput maksimum dari satu partisi.
Untuk mengatasi masalah ini, operasi `Scan` dapat secara logis membagi tabel atau indeks sekunder menjadi beberapa *segmen*, dengan beberapa pekerja aplikasi memindai segmen tersebut secara paralel. Setiap pekerja dapat berupa thread (dalam bahasa pemrograman yang mendukung multithreading) atau proses sistem operasi. Untuk melakukan pemindaian paralel, setiap pekerja mengeluarkan permintaan `Scan`-nya sendiri dengan parameter berikut:
+ `Segment` — Segmen yang akan dipindai oleh pekerja tertentu. Setiap pekerja harus menggunakan nilai yang berbeda untuk `Segment`.
+ `TotalSegments` — Jumlah total segmen untuk pemindaian paralel. Nilai ini harus sama dengan jumlah pekerja yang akan digunakan aplikasi Anda.
Diagram berikut menunjukkan bagaimana aplikasi multithreaded melakukan `Scan` paralel dengan tiga derajat paralelisme.
![\[Aplikasi multithreaded yang melakukan pemindaian paralel dengan membagi tabel menjadi tiga segmen.\]](http://docs.aws.amazon.com/id_id/amazondynamodb/latest/developerguide/images/ParallelScan.png)
Dalam diagram ini, aplikasi memunculkan tiga thread dan memberikan angka pada setiap thread. (Segmen berbasis nol, sehingga angka pertama selalu 0.) Setiap thread menerbitkan permintaan `Scan`, mengatur `Segment` ke angka yang ditunjuk dan mengatur `TotalSegments` ke 3. Setiap thread memindai segmen yang ditunjuk, mengambil data 1 MB pada satu waktu, dan mengembalikan data ke thread utama aplikasi.
DynamoDB menetapkan item *ke* segmen dengan menerapkan fungsi hash ke kunci partisi setiap item. Untuk `TotalSegments` nilai yang diberikan, semua item dengan kunci partisi yang sama selalu ditetapkan untuk yang sama`Segment`. Ini berarti bahwa dalam tabel di mana *Item 1*, *Item 2*, dan *Item 3* semuanya berbagi `pk="account#123"` (tetapi memiliki kunci pengurutan yang berbeda), item ini akan diproses oleh pekerja yang sama, terlepas dari nilai kunci pengurutan atau ukuran *koleksi item*.
Karena penetapan *segmen* hanya didasarkan pada hash kunci partisi, segmen dapat didistribusikan secara tidak merata. Beberapa segmen mungkin tidak berisi item, sementara yang lain mungkin berisi banyak kunci partisi dengan koleksi item besar. Akibatnya, peningkatan jumlah segmen tidak menjamin kinerja pemindaian yang lebih cepat, terutama ketika kunci partisi tidak didistribusikan secara merata di seluruh ruang kunci.
Nilai untuk `Segment` dan `TotalSegments` diterapkan untuk permintaan `Scan` individual, dan Anda dapat menggunakan nilai yang berbeda setiap saat. Anda mungkin perlu bereksperimen dengan nilai-nilai ini, dan jumlah pekerja yang Anda gunakan, sampai aplikasi Anda mencapai performa terbaiknya.
**catatan**
Pemindaian paralel dengan sejumlah besar pekerja dapat dengan mudah menggunakan semua throughput yang disediakan untuk tabel atau indeks yang sedang dipindai. Sebaiknya hindari pemindaian seperti itu jika tabel atau indeks juga mengalami aktivitas baca atau tulis yang berat dari aplikasi lain.
Untuk mengontrol jumlah data yang dikembalikan per permintaan, gunakan parameter `Limit`. Hal ini dapat membantu mencegah situasi di mana satu pekerja mengkonsumsi semua throughput yang ditetapkan, dengan mengorbankan semua pekerja lainnya.