VI.

Basis Data
Langkah-langkah awal dengan SQLite

Dalam bagian berikut dari tutorial pemrograman Android ini, kita akan berhenti di
deskripsikan berbagai opsi akses data yang disediakan oleh platform dan bagaimana
kita dapat melakukan tugas-tugas yang paling umum dalam bagian ini.

Platform Android menyediakan dua alat utama untuk penyimpanan dan

konsultasi data terstruktur:

Basis Data SQLite

Penyedia Konten

Pada bagian berikutnya, kita akan fokus pada pilihan pertama, SQLite, yang akan mencakup
semua tugas yang berkaitan dengan penyimpanan data milik kami
aplikasi. Mekanisme kedua, Content Providers, yang akan kita bahas lebih lanjut
lanjutkan, mereka akan memudahkan tugas kami untuk membuat data tersebut terlihat oleh aplikasi lain dan, secara
reciproka, untuk memungkinkan konsultasi data yang dipublikasikan oleh pihak ketiga dari aplikasi kami.

SQLiteini adalah mesin basis data yang sangat populer saat ini karena menawarkan fitur-fitur
sebanyak hal yang menarik seperti ukuran kecilnya, tidak memerlukan server, memerlukan sedikit konfigurasi,
sertransaksionaldan tentu saja menjadi kode bebas.

Android menyertakan secara standar semua alat yang diperlukan untuk penciptaan dan pengelolaan
basis data SQLite, dan di antaranya API lengkap untuk melakukan dengan cara yang sederhana
semua tugas yang diperlukan. Namun, di bagian pertama ini tentang basis data di
Android kita tidak akan masuk ke banyak detail dengan API ini. Untuk saat ini kita akan terbatas pada
lihat kode yang diperlukan untuk membuat database, kita akan memasukkan beberapa data percobaan, dan
kita akan melihat bagaimana kita bisa memeriksa bahwa semuanya berfungsi dengan baik.

Di Android, cara umum untuk membuat, memperbarui, dan terhubung dengan basis data SQLite
akan melalui kelas tambahan yang disebutSQLiteOpenHelper, atau lebih tepatnya, dari
kelas khusus yang diturunkan darinya dan yang harus kita sesuaikan untuk beradaptasi dengan
kebutuhan konkret dari aplikasi kami.

KelasSQLiteOpenHelperhanya memiliki satu konstruktor, yang biasanya tidak

kita perlu menimpa, dan dua metode abstrak,onCreate()yonUpgrade(), yang
kita harus menyesuaikan dengan kode yang diperlukan untuk membuat basis data kita dan untuk
memperbarui strukturnya masing-masing.

Sebagai contoh, kita akan membuat sebuah basis data yang sangat sederhana bernama
BDPengguna, dengan satu tabel bernama Pengguna yang hanya akan berisi dua kolom: nama
email. Untuk mereka, kita akan membuat kelas turunan dariSQLiteOpenHelperapa
kami akan memanggilUsuariosSQLiteHelper, di mana kita akan menimpa metode
onCreate()yonUpgrade()untuk mengadaptasi mereka ke dalam struktur data yang disebutkan:
paket [Link];

import [Link];
impor [Link];
impor [Link];
impor [Link];

publik kelas UsuariosSQLiteHelper memperluas SQLiteOpenHelper {

//Pernyataan SQL untuk membuat tabel Pengguna

CREATE TABLE Usuarios (codigo INTEGER, nombre TEXT)

publik UsuariosSQLiteHelper(Context contexto, String nombre,

CursorFactory factory, int versi) {
super(konteks, nama, pabrik, versi);
}

@Override
public void onCreate(SQLiteDatabase db) {
//Menjalankan pernyataan SQL untuk membuat tabel
[Link](sqlCreate);
}

@Override
publik void onUpgrade(SQLiteDatabase db, int versionSebelumnya,
int versiBaru) {
//NOTA: Untuk kesederhanaan contoh ini kami langsung menggunakan
// opsi untuk menghapus tabel sebelumnya dan membuatnya ulang
// kosong dengan format baru.
// Namun, yang biasa adalah bahwa harus melakukan migrasi data dari
// tabel lama ke yang baru, sehingga metode ini seharusnya
// menjadi lebih rumit.

//Versi sebelumnya dari tabel dihapus

[Link]("HAPUS TABEL JIKA ADA Usuarios");

//Versi baru dari tabel dibuat

[Link](sqlCreate);
}
}

mana kita menyimpan

Hal pertama yang kami lakukan adalah mendefinisikan sebuah variabel yang disebutsqlBuatdi

pernyataan SQL untuk membuat tabel bernama Pengguna dengan field alfanumerik nama dan
email. NOTA: Tujuan dari tutorial ini bukan untuk menggambarkan sintaksis bahasa SQL maupun
particularitas dari mesin basis data SQLite, sehingga saya tidak akan menjelaskan tentang itu
pernyataan SQL yang digunakan. Untuk informasi lebih lanjut tentang SQLite, Anda dapat merujuk ke
dokumen resmi atau mulai membaca pengantar kecil yang saya buat di sini
blog ketika saya membahas topik menggunakan SQLite dari aplikasi .NET

MetodeonCreate()akan dijalankan secara otomatis oleh kelas kami

UsuariosDBHelperketika pembuatan basis data diperlukan, yaitu ketika
belum ada. Tugas-tugas khas yang harus dilakukan dalam metode ini adalah pembuatan semua
tabel-tabel yang diperlukan dan penyisipan data awal jika perlu. Dalam kasus kami,
kita hanya akan membuat tabel Pengguna yang dijelaskan sebelumnya. Untuk pembuatan tabel
kita akan menggunakan pernyataan SQL yang telah didefinisikan dan menjalankannya terhadap basis data menggunakan
metode yang paling sederhana dari yang tersedia di API SQLite yang disediakan oleh Android,
panggilanexecSQL()Metode ini terbatas untuk menjalankan langsung kode SQL yang diberikan.
mari kita gunakan sebagai parameter.
Di sisi lain, metodeonUpgrade()akan diluncurkan secara otomatis ketika diperlukan
pembaruan struktur basis data atau konversi data.

Sebuah contoh praktis: mari kita bayangkan kita menerbitkan aplikasi yang menggunakan tabel dengan
kolom pengguna dan email (sebut saja versi 1 dari basis data). Kemudian, kita akan memperluas
fungsi dari aplikasi kami dan kami perlu agar tabel juga menyertakan sebuah kolom
tambahan misalnya dengan usia pengguna (versi 2 dari basis data kami). Jadi,
agar semuanya berfungsi dengan baik, pada saat kita pertama kali menjalankan versi yang diperluas dari
aplikasi perlu memodifikasi struktur tabel Pengguna untuk menambahkan yang baru
kolom usia. Karena hal-hal seperti ini yang akan diurus secara otomatis oleh
metodeonUpgrade()ketika kita mencoba membuka versi tertentu dari basis data
yang belum ada. Untuk itu, sebagai parameter menerima versi saat ini dari basis data di
sistem, dan versi baru yang ingin dijadikan. Berdasarkan pasangan data ini
kita perlu melakukan beberapa tindakan atau lainnya. Dalam contoh kasus kami, kita memilih untuk
opsi yang paling sederhana: menghapus tabel saat ini dan membuatnya kembali dengan struktur baru, tetapi
seperti yang diindikasikan dalam komentar kode, biasanya kita akan membutuhkan sesuatu yang lebih
logika untuk mengonversi database dari satu versi ke versi lain dan tentu saja untuk menjaga
data yang terdaftar sampai saat ini.

Setelah mendefinisikan kelas pembantu kami, pembukaan basis data dari aplikasi kami
ternyata adalah hal yang sangat sederhana. Yang pertama adalah membuat objek dari kelas
UsuariosSQLiteHelperyang akan kita lewati konteks aplikasi (dalam contoh ini sebuah
referensi ke aktivitas utama), nama basis data, sebuah objek
Fabrik Kursoryang biasanya tidak akan diperlukan (dalam hal itu kita akan memberikan nilainull),
dan terakhir versi basis data yang kita butuhkan. Pembuatan objek ini yang sederhana
dapat memiliki berbagai efek:

Jika basis data sudah ada dan versi saat ini sesuai dengan yang diminta, cukup
akan dilakukan koneksi dengannya.
Jika basis data ada tetapi versi saat ini lebih rendah dari yang diminta, akan disebut
otomatis ke metodeonUpgrade()untuk mengonversi basis data ke
versi baru dan akan terhubung dengan basis data yang telah dikonversi.
Jika basis data tidak ada, metode onCreate() akan dipanggil secara otomatis untuk
membuatnya dan akan terhubung dengan basis data yang dibuat.

Begitu kita memiliki referensi ke objekUsuariosSQLiteHelper, kami akan memanggil Anda

metodegetReadableDatabase()ogetWritableDatabase()untuk mendapatkan sebuah
referensi ke basis data, tergantung apakah kita hanya perlu mengakses data atau juga
kita perlu melakukan modifikasi, masing-masing.

Sekarang kita sudah mendapatkan referensi ke basis data (objek tipe

SQLiteDatabaseya kita bisa melakukan semua tindakan yang kita inginkan terhadapnya. Untuk
contoh kami akan membatasi diri untuk memasukkan 5 catatan percobaan, menggunakan untuk itu
metode yang telah dibahasexecSQL()dengan kalimat-kalimatSISIPKANcorrespondientes. Por último
kami menutup koneksi dengan basis data dengan memanggil metodetutup().
paket [Link];

impor [Link];
impor [Link];
impor [Link];

kelas AndroidBaseDatos memperluas Aktivitas

{
@Override
public void onCreate(Bundle savedInstanceState)
{
[Link](savedInstanceState);
setContentView([Link]);

//Kami membuka basis data 'DBUsuarios' dalam mode tulis

UsuariosSQLiteHelper usdbh =
new UsuariosSQLiteHelper(this, "DBUsuarios", null, 1);

SQLiteDatabase db = [Link]();

//Jika kita telah membuka database dengan benar

jika(db != null)
{
//Kami memasukkan 5 pengguna contoh
untuk(int i=1; i<=5; i++)
{
//Kami menghasilkan data
int kode = i;
String nombre = "Pengguna" + i;

//Kami memasukkan data ke dalam tabel Pengguna

[Link]("INSERT INTO Usuarios (codigo, nombre) " +
VALUES (
}

//Kami menutup basis data

[Link]();
}
}
}

Baiklah, lalu sekarang apa? Di mana basis data yang baru saja kami buat? Bagaimana kami bisa
memeriksa bahwa semuanya berjalan dengan baik dan bahwa catatan telah disisipkan dengan benar? Mari kita pergi
secara bertahap.

Pertama-tama mari kita lihat di mana database kita telah dibuat. Semua database
SQLite yang dibuat oleh aplikasi Android disimpan di memori ponsel dalam sebuah
berkas dengan nama yang sama dengan basis data yang terletak di jalur yang mengikuti yang berikut
pemberi kerja

/data/data/[Link]/bases_datos/nama_basis_data

Dalam contoh kami, basis data akan disimpan di jalur berikut:

/data/data/[Link]/databases/DBPengguna

Untuk memverifikasi ini, kita dapat melakukan hal berikut. Setelah dijalankan untuk pertama kalinya dari
Eclipse aplikasi contoh pada emulator Android (dan tentu saja sebelum
menutupnya) kita bisa pergi ke perspektif "DDMS" (Dalvik Debug Monitor Server) di Eclipse dan di
Dengan "File Explorer" kita dapat mengakses sistem file emulator, di mana
kita dapat mencari jalur yang ditunjukkan dari basis data. Kita bisa melihat ini di berikut
gambar:

Dengan ini kita sudah memeriksa setidaknya bahwa berkas basis data kita telah dibuat di
rute yang benar. Kita hanya perlu memeriksa bahwa baik tabel yang dibuat maupun data
yang dimasukkan juga telah termasuk dengan benar dalam basis data. Untuk itu kita dapat
menggunakan dua metode yang mungkin:

1. Transferir basis data ke PC kami dan konsultasikan dengan administrator manapun

basis data SQLite.
2. Akses langsung ke konsol perintah emulator Android dan gunakan
perintah yang ada untuk mengakses dan mengquery basis data SQLite.

Metode pertama adalah sederhana. Berkas basis data dapat kita transfer ke
PC kami menggunakan tombol unduh yang terletak di sudut kanan atas
penjelajah file (ditandai dengan merah pada gambar sebelumnya). Di samping tombol ini
muncul dua lainnya untuk melakukan operasi sebaliknya (menyalin file lokal ke sistem dari
berkas emulator) dan untuk menghapus file dari emulator. Setelah file diunduh ke
sistem lokal kami, kami dapat menggunakan pengelola SQLite mana pun untuk membuka dan
mengacu pada basis data, contohnyaAdministrator SQLite(perangkat lunak gratis)

Metode kedua menggunakan strategi yang berbeda. Alih-alih mengunduh basis data ke
sistem lokal kami, kamilah yang mengakses emulator secara jarak jauh
melalui konsol perintahnya (shell). Untuk itu, dengan emulator Android yang masih terbuka,
kita harus membuka konsol MS-DOS dan menggunakan utilitas [Link] (Jembatan Debug Android)
terletak di dalam folderalat-platformdel SDK Android (dalam kasus saya:c:\android-
sdk-windows\platform-tools\) Pertama-tama kita akan memeriksa pengenal
semua emulator yang berjalan melalui perintah “perangkat adb. Ini harus kita
mengembalikan satu instance jika kita hanya memiliki satu emulator terbuka, yang dalam kasus saya khususnya
lamaemulator-5554“.
Setelah mengetahui pengenal emulasi kami, kita akan mengakses shell-nya melalui
perintahadb -s pengenal-emulator shell. Setelah terhubung, sudah
kita dapat mengakses basis data kita menggunakan perintahsqlite3mengoper rute
del fichero, para nuestro ejemplo “sqlite3 /data/data/[Link]/
databases/DBPengguna. Jika semuanya berjalan lancar, prompt SQLite harus muncul.
“sqlite>, yang akan menunjukkan kepada kita bahwa kita sudah bisa menulis kueri SQL yang diperlukan tentang
basis data kami. Kami akan memeriksa bahwa tabel Pengguna ada dan bahwa telah
memasukkan lima catatan contoh. Untuk itu kita akan melakukan kueri berikut: "PILIH *
DARI Pengguna;. Jika semuanya benar, instruksi ini harus mengembalikan lima pengguna
yang ada di tabel. Gambar berikut menunjukkan seluruh proses yang dijelaskan:

Dengan ini kami telah memeriksa bahwa basis data kami telah dibuat dengan benar,
semua catatan contoh telah dimasukkan dan semuanya berfungsi sesuai harapan.

Dalam bagian berikut, kita akan membahas berbagai kemungkinan yang kita miliki dalam hal
memanipulasi data dalam basis data (menyisipkan, menghapus, dan memodifikasi data) dan bagaimana
kita bisa melakukan konsultasi tentang hal yang sama, karena [seperti biasa] kita akan memiliki beberapa
pilihan yang tersedia.

Menyisipkan/Memperbarui/Menghapus
Pada bagian sebelumnya dari kursus pemrograman di Android, kita telah melihat bagaimana cara membuat sebuah basis data.

data untuk menggunakannya dari aplikasi Android kami. Di bagian kedua dari seri ini
kita akan menggambarkan kemungkinan alternatif yang disediakan oleh API Android saat
menyisipkan, memperbarui dan menghapus catatan dari basis data SQLite kami.

API SQLite di Android menyediakan dua alternatif untuk melakukan operasi pada
basis data yang tidak mengembalikan hasil (termasuk penyisipan/pembaruan/penghapusan
dari catatan, tetapi juga pembuatan tabel, indeks, dll).
Yang pertama, yang telah kami bahas secara singkat di bagian sebelumnya, adalah metode
execSQL()dari kelasSQLiteDatabaseMetode ini memungkinkan untuk menjalankan apapun
pernyataan SQL tentang basis data, selama itu tidak mengembalikan hasil. Untuk itu,
kami hanya akan memberikan sebagai parameter masukan untuk metode ini string teks
sesuai dengan pernyataan SQL. Ketika kami membuat basis data di pos sebelumnya sudah
kami melihat beberapa contoh dari ini untuk memasukkan catatan pengujian. Contoh lain bisa jadi
yang berikut:

//Memasukkan sebuah catatan

[Link]("INSERT INTO Usuarios (usuario,email) VALUES ")
('usu1','usu1@[Link]')

//Menghapus sebuah catatan

[Link]("HAPUS DARI Usuarios DI MANA usuario='usu1' ");

//Memperbarui sebuah catatan

[Link]("UPDATE Usuarios SET email='nuevo@[Link]' WHERE usuario='usu1'")
");

Alternatif kedua yang tersedia di API Android adalah menggunakan metode

masukkan(), perbarui()yhapus()diberikan juga dengan kelas
Basis Data SQLiteMetode ini memungkinkan untuk melakukan tugas penyisipan, pembaruan, dan
penghapusan catatan dengan cara yang lebih parametrik daripadaexecSQL(), memisahkan
tabel, nilai, dan kondisi pada parameter independen dari metode ini.

Mari kita mulai dengan metodesematkan()untuk menyisipkan catatan baru ke dalam database.
Metode ini menerima tiga parameter, yang pertama adalah nama tabel, yang ketiga
akan menjadi nilai-nilai dari catatan yang akan dimasukkan, dan yang kedua akan kita abaikan untuk saat ini karena begitu
hanya diperlukan dalam kasus yang sangat spesifik (misalnya untuk dapat memasukkan catatan
benar-benar kosong), dalam kasus lain kita akan lanjut dengan nilai null detik ini
parameter.

Nilai yang akan dimasukkan akan kita sampaikan sebagai elemen dari suatu koleksi jenis
NilaiKonten. Koleksi ini adalah jenis kamus, di mana kita akan menyimpan pasangan dari
kunci-nilai, di mana kunci akan menjadi nama setiap field dan nilai akan menjadi data
correspondiente a insertar en dicho campo.

Mari kita lihat contohnya:

//Kami membuat catatan untuk disisipkan sebagai objek ContentValues

ContentValues nuevoRegistro = new ContentValues();
[Link]("usuario", "usu10");
[Link]("email","usu10@[Link]");

//Kami memasukkan rincian ke dalam basis data

[Link]("Pengguna", null, baruRegistrasi);

Metodeperbarui()yhapus()akan digunakan dengan cara yang sangat mirip dengan ini, dengan
salvedad bahwa mereka akan menerima parameter tambahan dengan kondisiDI MANAKAHdari putusan
SQL. Misalnya, untuk memperbarui email pengguna dengan nama 'usu1' kita akan melakukan hal berikut:
//Kami menetapkan bidang-nilai yang akan diperbarui
ContentValues valores = new ContentValues();
[Link]("email","usu1_nuevo@[Link]");

Kami memperbarui catatan di database

[Link]("Pengguna", nilai, "pengguna='usu1'");

Seperti yang kita lihat, sebagai parameter ketiga dari metodeperbarui()kami langsung melewati
kondisi dariPEMBARUANseperti yang akan kami lakukan dalam klausulDIMANAdalam sebuah pernyataan SQL
normal.

Metodehapus()akan digunakan dengan cara yang sama. Misalnya untuk menghapus catatan dari
pengguna 'usu2' kami akan melakukan hal berikut:

//Kami menghapus catatan pengguna 'usu2'

[Link]("Pengguna", "pengguna='usu2'");

Seperti yang kita lihat, kita kembali melewatkan sebagai parameter pertama nama tabel dan yang kedua
tempat syaratDI MANA. Tentu saja, jika kita tidak memerlukan kondisi apapun, kita bisa
tinggalkan sepertinullpada parameter ini.

Satu detail terakhir tentang metode ini. Baik dalam kasusexecSQL()seperti dalam kasus
deperbarui()ohapus()kita dapat menggunakan argumen di dalam kondisi dari
pernyataan SQL. Ini hanya bagian variabel dari pernyataan SQL yang akan kami berikan di
mengubah nilai terpisah, yang akan mencegah kita mengalami situasi khas di mana kita memiliki
yang membangun pernyataan SQL dengan menggabungkan string teks dan variabel untuk membentuk
komando SQL final. Argumen SQL ini akan ditunjukkan dengan simbol ‘?’, dan nilai dari
argumen-argumen tersebut harus dimasukkan dalam array dalam urutan yang sama seperti yang muncul dalam pernyataan
SQL. Jadi, misalnya, kita bisa menulis instruksi seperti yang berikut ini:

//Menghapus sebuah catatan dengan execSQL(), menggunakan argumen

String[] args = new String[]{"usu1"};
[Link]("HAPUS DARI Usuarios DIMANA usuario=?, args");

//Perbarui dua catatan dengan update(), menggunakan argumen

ContentValues valores = new ContentValues();
[Link]("email","usu1_nuevo@[Link]");

String[] args = new String[]{"usu1", "usu2"};

[Link]("Pengguna", nilai, "pengguna=? ATAU pengguna=?", args);

Cara ini untuk meneruskan data variabel tertentu ke dalam pernyataan SQL dapat membantu kita
selain itu menulis kode yang lebih bersih dan menghindari kemungkinan kesalahan.

Pada bagian berikutnya kita akan melihat cara mengquery basis data untuk mengambil catatan
berdasarkan kriteria tertentu.

Konsultasi/Mengambil catatan

Pada bagian sebelumnya dari kursus, kita melihat semua opsi yang tersedia saat memasukkan,
memperbarui dan menghapus data dari basis data SQLite di Android. Dalam edisi baru ini
kita akan mendeskripsikan tugas terakhir dari pengolahan data penting yang tersisa
melihat, pemilihan dan pemulihan data.

Dengan cara yang mirip dengan apa yang kita lihat untuk pernyataan modifikasi data, kita akan memiliki
dua opsi utama untuk mengambil catatan dari basis data SQLite di Android. La
yang pertama menggunakannya langsung dengan perintah seleksi SQL, dan sebagai yang kedua
opsi menggunakan metode spesifik di mana kita akan memparametrisasi kueri ke basis data
data.

Untuk pilihan pertama kita akan menggunakan metoderawQuery()dari kelasBasis Data SQLite.
Metode ini menerima langsung sebagai parameter sebuah perintah SQL lengkap, di mana
kami menunjukkan bidang yang akan diambil dan kriteria pemilihan. Hasil dari kueri itu
kita akan mendapatkan dalam bentuk kursor, yang kemudian dapat kita telusuri untuk memproses
catatan yang dipulihkan. Gunakan kueri berikut sebagai contoh:

Cursor c = [Link](" SELECT usuario,email FROM Usuarios WHERE ")

usuario='usu1' );

Seperti halnya metode modifikasi data, kita juga dapat menambahkan ini
metode daftar argumen variabel yang telah kita tunjukkan dalam perintah SQL dengan
simbol '?', contohnya begini:

String[] args = new String[] {"usu1"};

Kursor c = [Link](" SELECT usuario,email FROM Usuarios WHERE usuario=? ",
args);

Lebih lanjut di bagian ini kita akan melihat bagaimana kita dapat memanipulasi objek Cursor untuk
memulihkan data yang diperoleh.

Sebagai opsi kedua untuk memulihkan data, kita bisa menggunakan metodekueri()dari kelas
Basis Data SQLite. Metode ini menerima beberapa parameter: nama tabel, sebuah array
dengan nama-nama bidang yang akan diambil, klausa DI MANA, sebuah array dengan argumen
variabel yang termasuk dalamDIMANA(jika ada,nulljika tidak demikian), klausa GROUP BY jika
ada, klausaMEMILIKIjika ada, dan akhirnya klausulURUTKAN MENURUTsi ada.
Opsional, Anda dapat menyertakan parameter di akhir yang menunjukkan jumlah maksimum dari
catatan yang ingin kami kembalikan dari kueri. Mari kita lihat contoh yang sama sebelumnya
menggunakan metodekueri():

String[] campos = new String[] {"usuario", "email"};

String[] args = new String[] {"usu1"};

Kursor c = [Link]("Pengguna", campos, "pengguna=?", args, null, null, null);

Seperti yang kita lihat, hasilnya dikembalikan kembali dalam objek Cursor yang harus kita
mengulang untuk memproses data yang diperoleh.
Untuk menjelajahi dan memanipulasi kursor yang dikembalikan oleh salah satu dari dua metode yang disebutkan
kami memiliki beberapa metode dari kelas tersebutKursor, di antara yang kami soroti
dua dari yang didedikasikan untuk menjelajahi kursor secara berurutan dan dalam urutan alami:

pindahKePertama()geser kursor ke catatan pertama yang dikembalikan.

moveToNext()geser kursor ke catatan berikutnya yang dikembalikan.

MetodepindahKePertama()ypindahKeBerikutnya()mengembalikanBENARjika ada
dilakukan pergerakan yang sesuai dari penunjuk tanpa kesalahan, yaitu, selama selalu ada
sebuah catatan awal atau catatan berikutnya, masing-masing.

Setelah diposisikan di setiap catatan, kita dapat menggunakan salah satu metode.
getXXX(indeks_kolom)menuju untuk setiap jenis data untuk mengambil data dari
setiap bidang dari catatan saat ini dari kursor. Jadi, jika kita ingin mengambil misalnya yang kedua
kolom dari catatan saat ini, dan ini berisi field alfanumerik, kita akan melakukan panggilan
getString(1)[NOTA: indeks dimulai dari 0, sehingga kolom kedua memiliki
indeks 1], jika mengandung data tipe real kita akan menyebutnyagetDouble(1), dan dengan cara
analog untuk semua jenis data yang ada. Dengan mempertimbangkan semua ini, mari kita lihat bagaimana
kita bisa menjelajahi kursor yang dikembalikan oleh contoh sebelumnya:

String[] campos = new String[] {"usuario", "email"};

String[] args = new String[] {"usu1"};

Cursor c = [Link]("Pengguna", campos, "pengguna=?", args, null, null, null);

//Kami memastikan bahwa setidaknya ada satu catatan

jika ([Link]()) {
Kami menjelajahi kursor hingga tidak ada lagi catatan
lakukan {
String pengguna = [Link](0);
String email = [Link](1);
} while([Link]());
}

Selain metode yang dibahas di kelasKursorada jauh lebih banyak daripada kami
dapat berguna dalam banyak kesempatan. Misalnya,getCount()akan memberi tahu Anda jumlah total dari
rekor yang dikembalikan dalam kursor,getNamaKolom(i)kembalikan nama kolom
dengan indeks i,pindahKePosisi(i)geser pointer kursor ke entri dengan indeks i, dll.
Anda dapat melihat daftar lengkap metode yang tersedia dikelas Kursordi dalam
dokumentasi resmi Android.

Dengan ini, kami menyelesaikan rangkaian bagian dasar yang didedikasikan untuk tugas pemeliharaan
de datos di aplikasi Android melalui basis data SQLite. Saya menyadari bahwa
kami meninggalkan beberapa topik yang sedikit lebih maju (seperti misalnya penggunaan
transaksi, yang akan saya coba bahas lebih lanjut), tetapi dengan metode yang dijelaskan kita dapat
melakukan persentase yang cukup tinggi dari semua tugas yang diperlukan terkait dengan pengobatan
data terstruktur dalam aplikasi Android.