Python 2.7 telah mencapai akhir dukungan
dan akan dihentikan penggunaannya
pada 31 Januari 2026. Setelah penghentian penggunaan, Anda tidak akan dapat men-deploy aplikasi Python 2.7, meskipun organisasi Anda sebelumnya menggunakan kebijakan organisasi untuk mengaktifkan kembali deployment runtime lama. Aplikasi Python 2.7 yang ada akan terus berjalan dan menerima traffic setelah
tanggal penghentiannya. Sebaiknya Anda bermigrasi ke versi Python terbaru yang didukung.
Tetap teratur dengan koleksi
Simpan dan kategorikan konten berdasarkan preferensi Anda.
Query Cursor memudahkan aplikasi mengambil hasil kueri dalam batch,
dan lebih direkomendasikan daripada penggunaan offset bilangan bulat untuk penomoran halaman.
Lihat Kueri untuk mengetahui informasi selengkapnya tentang pembuatan struktur kueri untuk aplikasi Anda.
Query Cursor
Query Cursor memudahkan aplikasi mengambil hasil kueri dalam batch
tanpa menimbulkan overhead offset kueri. Setelah melakukan
operasi pengambilan, aplikasi dapat memperoleh
kursor, yang merupakan string yang dienkode sebagai base64 bersifat opaque yang menandai posisi indeks
hasil terakhir yang diambil. Aplikasi dapat menyimpan string ini, misalnya di
Datastore, di Memcache, di payload tugas Task Queue, atau disematkan di
halaman web sebagai parameter GET atau POST HTTP, dan dapat menggunakan kursor sebagai titik awal untuk operasi pengambilan berikutnya guna mendapatkan batch hasil berikutnya dari titik akhir pengambilan sebelumnya. Pengambilan juga dapat
menentukan kursor akhir untuk membatasi sejauh mana kumpulan hasil yang ditampilkan.
Offset versus kursor
Meskipun Datastore mendukung offset bilangan bulat, Anda harus menghindari penggunaannya. Sebagai gantinya, gunakan kursor. Penggunaan offset hanya akan menghindari ditampilkannya
entity yang dilewati ke aplikasi Anda, tetapi entity ini masih diambil
secara internal. Entity yang dilewati memengaruhi latensi kueri dan aplikasi Anda akan dikenai biaya untuk operasi baca yang diperlukan untuk mengambil dokumen tersebut. Dengan
menggunakan kursor, bukan offset, Anda dapat menghindari semua biaya ini.
Contoh query cursor
Di Python, aplikasi memperoleh kursor setelah mengambil hasil kueri dengan
memanggil metode cursor() objek Query. Untuk
mengambil hasil tambahan dari titik kursor, aplikasi
akan menyiapkan kueri serupa dengan jenis, memfilter, dan menata urutan entity yang sama,
serta meneruskan kursor ke
kueri with_cursor() sebelum melakukan
pengambilan:
fromgoogle.appengine.apiimportmemcachefromgoogle.appengine.extimportdb# class Person(db.Model): ...# Start a query for all Person entitiespeople=Person.all()# If the application stored a cursor during a previous request, use itperson_cursor=memcache.get('person_cursor')ifperson_cursor:people.with_cursor(start_cursor=person_cursor)# Iterate over the resultsforpersoninpeople:# Do something# Get updated cursor and store it for next timeperson_cursor=people.cursor()memcache.set('person_cursor',person_cursor)
Batasan kursor
Kursor tunduk pada batasan berikut:
Kursor hanya dapat digunakan oleh aplikasi yang sama yang menjalankan kueri
asli, dan hanya untuk melanjutkan kueri yang sama. Untuk menggunakan kursor dalam
operasi pengambilan berikutnya, Anda harus menyusun ulang kueri asli dengan tepat,
termasuk jenis entity, filter ancestor, filter properti, dan tata
urutan yang sama. Anda tidak dapat mengambil hasil menggunakan kursor tanpa menyiapkan kueri yang sama dengan yang awalnya dibuat.
Karena operator != dan IN diimplementasikan dengan beberapa kueri, kueri yang menggunakannya tidak mendukung kursor.
Kursor tidak selalu berfungsi seperti yang diharapkan dengan kueri yang menggunakan filter ketidaksetaraan atau tata urutan pada properti dengan beberapa nilai. Logika de-duplikasi
untuk properti multi-nilai tersebut tidak akan dipertahankan di antara pengambilan,
yang mungkin menyebabkan hasil yang sama ditampilkan lebih dari sekali.
Rilis App Engine baru dapat mengubah detail implementasi internal, sehingga membatalkan validasi kursor yang bergantung padanya. Jika aplikasi mencoba menggunakan kursor yang tidak lagi valid, Datastore akan memunculkan pengecualian BadRequestError.
Kursor dan pembaruan data
Posisi kursor ditentukan sebagai lokasi dalam daftar hasil setelah
hasil terakhir ditampilkan. Kursor bukan merupakan posisi relatif dalam daftar
(bukan offset); kursor adalah penanda yang dapat dilewati Datastore
saat memulai pemindaian indeks untuk mendapatkan hasil. Jika hasil kueri berubah
di antara penggunaan kursor, kueri hanya akan melihat perubahan yang terjadi dalam hasil
setelah kursor. Jika hasil baru muncul sebelum posisi kursor untuk kueri, hasil tersebut tidak akan ditampilkan jika hasilnya baru muncul setelah kursor diambil.
Demikian pula, jika suatu entity bukan lagi hasil kueri, tetapi telah muncul
sebelum kursor, hasil yang muncul setelah kursor tidak berubah. Jika
hasil terakhir yang ditampilkan dihapus dari kumpulan hasil, kursor masih mengetahui
cara menemukan hasil berikutnya.
Saat mengambil hasil kueri, Anda dapat menggunakan kursor awal dan kursor akhir
untuk menampilkan grup hasil berkelanjutan dari Datastore. Saat
menggunakan kursor awal dan akhir untuk mengambil hasil, tidak ada jaminan
bahwa ukuran hasilnya akan sama seperti saat membuat kursor.
Entity dapat ditambahkan atau dihapus dari Datastore antara
saat kursor dibuat dan saat kursor digunakan dalam kueri.
[[["Mudah dipahami","easyToUnderstand","thumb-up"],["Memecahkan masalah saya","solvedMyProblem","thumb-up"],["Lainnya","otherUp","thumb-up"]],[["Sulit dipahami","hardToUnderstand","thumb-down"],["Informasi atau kode contoh salah","incorrectInformationOrSampleCode","thumb-down"],["Informasi/contoh yang saya butuhkan tidak ada","missingTheInformationSamplesINeed","thumb-down"],["Masalah terjemahan","translationIssue","thumb-down"],["Lainnya","otherDown","thumb-down"]],["Terakhir diperbarui pada 2025-09-04 UTC."],[[["\u003cp\u003eQuery cursors allow applications to retrieve query results in batches, marking the position of the last retrieved result as an opaque, base64-encoded string.\u003c/p\u003e\n"],["\u003cp\u003eUsing cursors instead of integer offsets is recommended because offsets still retrieve skipped entities internally, affecting latency and incurring read operation costs.\u003c/p\u003e\n"],["\u003cp\u003eCursors can be saved and used later to continue a query from where it left off, allowing applications to get the next batch of results.\u003c/p\u003e\n"],["\u003cp\u003eCursors have limitations, such as only being usable by the same application for the same query and not supporting \u003ccode\u003e!=\u003c/code\u003e and \u003ccode\u003eIN\u003c/code\u003e operators.\u003c/p\u003e\n"],["\u003cp\u003eThe position of a cursor is defined as the location after the last returned result, and while it is not affected by results that come before the cursor, new additions or removals after the cursor can impact results.\u003c/p\u003e\n"]]],[],null,["# Query Cursors\n\n*Query cursors* allow an application to retrieve a query's results in convenient\nbatches, and are recommended over using integer offsets for pagination.\nSee [Queries](/appengine/docs/legacy/standard/python/datastore/queries) for more information on structuring queries for your app.\n\nQuery cursors\n-------------\n\n*Query cursors* allow an application to retrieve a query's results in convenient\nbatches without incurring the overhead of a query offset. After performing a\n[retrieval operation](/appengine/docs/legacy/standard/python/datastore/retrieving-query-results), the application can obtain a\ncursor, which is an opaque base64-encoded string marking the index position of\nthe last result retrieved. The application can save this string, for example in\nDatastore, in Memcache, in a Task Queue task payload, or embedded in\na web page as an HTTP `GET` or `POST` parameter, and can then use the cursor as\nthe starting point for a subsequent retrieval operation to obtain the next batch\nof results from the point where the previous retrieval ended. A retrieval can\nalso specify an end cursor, to limit the extent of the result set returned.\n\nOffsets versus cursors\n----------------------\n\nAlthough Datastore supports integer offsets, you should avoid\nusing them. Instead, use cursors. Using an offset only avoids returning the\nskipped entities to your application, but these entities are still retrieved\ninternally. The skipped entities do affect the latency of the query, and your\napplication is billed for the read operations required to retrieve them. Using\ncursors instead of offsets lets you avoid all these costs.\n\nQuery cursor example\n--------------------\n\nIn Python, an application obtains a cursor after retrieving query results by\ncalling the `Query` object's [`cursor()`](/appengine/docs/legacy/standard/python/datastore/queryclass#Query_cursor) method. To\nretrieve additional results from the point of the cursor, the application\nprepares a similar query with the same entity kind, filters, and sort orders,\nand passes the cursor to the query's\n[`with_cursor()`](/appengine/docs/legacy/standard/python/datastore/queryclass#Query_with_cursor) method before performing the\nretrieval: \n\n from google.appengine.api import memcache\n from google.appengine.ext import db\n\n # class Person(db.Model): ...\n \n # Start a query for all Person entities\n people = Person.all()\n \n # If the application stored a cursor during a previous request, use it\n person_cursor = memcache.get('person_cursor')\n if person_cursor:\n people.with_cursor(start_cursor=person_cursor)\n \n # Iterate over the results\n for person in people:\n # Do something\n \n # Get updated cursor and store it for next time\n person_cursor = people.cursor()\n memcache.set('person_cursor', person_cursor)\n\n| **Note:** Because of the way the iterator interface retrieves results in batches, getting a cursor may result in an additional call to Datastore to position the cursor where the iterator left off. If using only a start cursor, and if you know how many results you need ahead of time, it's faster to use [`fetch()`](/appengine/docs/legacy/standard/python/datastore/queryclass#Query_fetch).\n| **Caution:** Be careful when passing a Datastore cursor to a client, such as in a web form. Although the client cannot change the cursor value to access results outside of the original query, it is possible for it to decode the cursor to expose information about result entities, such as the application ID, entity kind, key name or numeric ID, ancestor keys, and properties used in the query's filters and sort orders. If you don't want users to have access to that information, you can encrypt the cursor, or store it and provide the user with an opaque key.\n\n### Limitations of cursors\n\nCursors are subject to the following limitations:\n\n- A cursor can be used only by the same application that performed the original query, and only to continue the same query. To use the cursor in a subsequent retrieval operation, you must reconstitute the original query exactly, including the same entity kind, ancestor filter, property filters, and sort orders. It is not possible to retrieve results using a cursor without setting up the same query from which it was originally generated.\n- Because the `!=` and `IN` operators are implemented with multiple queries, queries that use them do not support cursors.\n- Cursors don't always work as expected with a query that uses an inequality filter or a sort order on a property with multiple values. The de-duplication logic for such multiple-valued properties does not persist between retrievals, possibly causing the same result to be returned more than once.\n- New App Engine releases might change internal implementation details, invalidating cursors that depend on them. If an application attempts to use a cursor that is no longer valid, Datastore raises a [`BadRequestError`](/appengine/docs/legacy/standard/python/datastore/exceptions#BadRequestError) exception.\n\n### Cursors and data updates\n\nThe cursor's position is defined as the location in the result list after the\nlast result returned. A cursor is not a relative position in the list\n(it's not an offset); it's a marker to which Datastore can jump\nwhen starting an index scan for results. If the results for a query change\nbetween uses of a cursor, the query notices only changes that occur in results\nafter the cursor. If a new result appears before the cursor's position for the\nquery, it will not be returned when the results after the cursor are fetched.\nSimilarly, if an entity is no longer a result for a query but had appeared\nbefore the cursor, the results that appear after the cursor do not change. If\nthe last result returned is removed from the result set, the cursor still knows\nhow to locate the next result.\n\nWhen retrieving query results, you can use both a start cursor and an end cursor\nto return a continuous group of results from Datastore. When\nusing a start and end cursor to retrieve the results, you are not guaranteed\nthat the size of the results will be the same as when you generated the cursors.\nEntities may be added or deleted from Datastore between the\ntime the cursors are generated and when they are used in a query.\n\nWhat's next?\n------------\n\n- [Learn how to specify what a query returns and further control query\n results](/appengine/docs/legacy/standard/python/datastore/retrieving-query-results).\n- Learn the [common restrictions](/appengine/docs/legacy/standard/python/datastore/query-restrictions) for queries on Datastore.\n- [Understand data consistency](/appengine/docs/legacy/standard/python/datastore/data-consistency) and how data consistency works with different types of queries on Datastore.\n- Learn the [basic syntax and structure of queries](/appengine/docs/legacy/standard/python/datastore/queries) for Datastore."]]