1. Pengenalan tentang Operasi Entitas dalam ent

Panduan ini akan secara komprehensif memandu Anda untuk menguasai operasi entitas dalam kerangka kerja ent, mencakup proses lengkap dalam membuat, menanyakan, memperbarui, dan menghapus entitas. Panduan ini cocok untuk pemula yang ingin secara bertahap memahami fungsionalitas inti dari ent.

3. Operasi Pembuatan Entitas

3.1 Membuat Sebuah Entitas Tunggal

Membuat entitas adalah operasi dasar untuk persistensi data. Berikut adalah langkah-langkah untuk membuat objek entitas tunggal menggunakan kerangka kerja ent dan menyimpannya ke dalam database:

  1. Pertama, tentukan struktur dan bidang-bidang entitas, yaitu, tentukan model dari entitas dalam file schema.
  2. Jalankan perintah ent generate untuk menghasilkan kode operasi entitas yang sesuai.
  3. Gunakan metode Create yang dihasilkan untuk membangun entitas baru, dan atur nilai-nilai bidang entitas melalui pemanggilan berantai.
  4. Terakhir, panggil metode Save untuk menyimpan entitas ke dalam database.

Berikut adalah contoh yang menunjukkan bagaimana membuat dan menyimpan entitas pengguna:

package main

import (
    "context"
    "log"
    "entdemo/ent"
)

func main() {
    // Membuat instance Klien untuk interaksi dengan database
    client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("Gagal membuka koneksi database: %v", err)
    }
    defer client.Close()

    // Membuat konteks
    ctx := context.Background()
    
    // Membuat entitas pengguna menggunakan Klien
    a8m, err := client.User.
        Create().
        SetName("a8m").
        Save(ctx)
    if err != nil {
        log.Fatalf("Gagal membuat entitas pengguna: %v", err)
    }

    // Entitas berhasil disimpan ke dalam database
    log.Printf("Entitas pengguna disimpan: %v", a8m)
}

Pada contoh ini, sebuah klien basis data client dibuat terlebih dahulu. Kemudian, metode User.Create digunakan untuk mengatur atribut-atribut pengguna baru, dan terakhir, metode Save dipanggil untuk menyimpan pengguna ke dalam database.

3.2 Pembuatan Entitas dalam Jumlah Besar

Dalam beberapa skenario, mungkin ada kebutuhan untuk membuat beberapa entitas, seperti saat inisialisasi basis data atau operasi impor data dalam jumlah besar. Kerangka kerja ent menyediakan kemampuan untuk membuat entitas secara masal, yang menawarkan kinerja yang lebih baik dibandingkan dengan membuat dan menyimpan entitas secara individu.

Langkah-langkah untuk pembuatan entitas dalam jumlah besar adalah sebagai berikut:

  1. Gunakan metode CreateBulk alih-alih metode Create, yang memungkinkan pembuatan multiple entitas dalam satu operasi.
  2. Panggil Create untuk setiap entitas yang akan dibuat.
  3. Setelah semua entitas telah dibuat, gunakan metode Save untuk menyimpan entitas ke dalam database secara masal.

Berikut adalah contoh pembuatan entitas dalam jumlah besar:

package main

import (
    "context"
    "log"
    "entdemo/ent"
)

func main() {
    client, err := ent.Open("sqlite3", "file:ent?mode=memory&cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("Gagal membuka koneksi database: %v", err)
    }
    defer client.Close()
    ctx := context.Background()

    // Membuat entitas Pet secara masal
    pets, err := client.Pet.CreateBulk(
        client.Pet.Create().SetName("pedro").SetOwner(a8m),
        client.Pet.Create().SetName("xabi").SetOwner(a8m),
        client.Pet.Create().SetName("layla").SetOwner(a8m),
    ).Save(ctx)
    if err != nil {
        log.Fatalf("Gagal dalam pembuatan entitas Pet secara masal: %v", err)
    }

    log.Printf("Dibuat %d entitas Pet secara masal\n", len(pets))
}

Pada contoh ini, sebuah client didirikan terlebih dahulu, kemudian beberapa entitas Pet dibangun menggunakan metode CreateBulk, mengatur nama dan pemilik mereka. Semua entitas disimpan ke dalam database sekaligus saat metode Save dipanggil, memberikan kinerja yang lebih baik dalam menangani jumlah data yang besar.

4. Operasi Kueri Entitas

4.1 Kueri Dasar

Kueri basis data adalah cara fundamental untuk mengambil informasi. Di ent, metode Query digunakan untuk memulai kueri. Berikut adalah langkah-langkah dan contoh kueri entitas dasar:

  1. Pastikan Anda memiliki instance Client yang dapat digunakan.
  2. Gunakan Client.Query() atau metode bantu entitas seperti Pet.Query() untuk membuat kueri.
  3. Tambahkan kondisi penyaringan sesuai kebutuhan, seperti Where.
  4. Jalankan kueri dan dapatkan hasilnya dengan memanggil metode All.
package main

import (
    "context"
    "log"
    "entdemo/ent"
    "entdemo/ent/user"
)

func main() {
    client, err := ent.Open("sqlite3", "file:ent?cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("Gagal membuka koneksi database: %v", err)
    }
    defer client.Close()
    ctx := context.Background()

    // Kueri semua pengguna yang bernama "a8m"
    users, err := client.User.
        Query().
        Where(user.NameEQ("a8m")).
        All(ctx)
    if err != nil {
        log.Fatalf("Gagal mengkueri pengguna: %v", err)
    }

    for _, u := range users {
        log.Printf("Ditemukan pengguna: %#v\n", u)
    }
}

Contoh ini menunjukkan cara menemukan semua pengguna dengan nama "a8m".

4.2 Pergeseran Halaman dan Pengurutan

Pergeseran halaman dan pengurutan adalah fitur lanjutan yang umum digunakan saat melakukan kueri, digunakan untuk mengontrol urutan dan jumlah output data. Berikut adalah cara mencapai kueri pergeseran halaman dan pengurutan menggunakan ent:

  1. Gunakan metode Limit untuk menetapkan jumlah maksimum hasil yang akan dikembalikan.
  2. Gunakan metode Offset untuk melewati beberapa hasil sebelumnya.
  3. Gunakan metode Order untuk menentukan bidang pengurutan dan arahnya.

Berikut adalah contoh kueri pergeseran halaman dan pengurutan:

package main

import (
    "context"
    "log"
    "entdemo/ent"
    "entdemo/ent/pet"
)

func main() {
    client, err := ent.Open("sqlite3", "file:ent?cache=shared&_fk=1")
    if err != nil {
        log.Fatalf("Gagal membuka koneksi database: %v", err)
    }
    defer client.Close()
    ctx := context.Background()

    // Kueri Hewan Peliharaan secara turun berdasarkan usia dengan paginasi
    pets, err := client.Pet.
        Query().
        Order(ent.Desc(pet.FieldAge)).
        Limit(10).
        Offset(0).
        All(ctx)
    if err != nil {
        log.Fatalf("Gagal mengkueri Hewan Peliharaan: %v", err)
    }

    for _, p := range pets {
        log.Printf("Ditemukan Hewan Peliharaan: %#v\n", p)
    }
}

Contoh ini menunjukkan cara mengambil halaman pertama, hingga 10 catatan, dari hewan peliharaan yang diurutkan secara turun berdasarkan usia. Dengan memodifikasi nilai Limit dan Offset, Anda dapat mencapai penomoran halaman melalui keseluruhan kumpulan data.

5. Operasi Pembaruan Entitas

5.1 Memperbarui Satu Entitas

Dalam banyak aplikasi, memperbarui entitas adalah bagian penting dari operasi harian. Dalam bagian ini, kami akan menunjukkan cara menggunakan kerangka kerja Ent untuk memperbarui satu entitas di database.

Pertama, berasumsi bahwa kita perlu memperbarui usia pengguna, kita dapat memanfaatkan metode Update yang dihasilkan oleh Ent.

// Dengan asumsi kita sudah memiliki entitas pengguna 'a8m' dan konteks 'ctx'

a8m, err := a8m.Update().         // Buat pembuat pembaruan pengguna
    SetAge(30).                   // Atur usia pengguna menjadi 30 tahun
    Save(ctx)                     // Lakukan operasi simpan dan kembalikan hasilnya
if err != nil {
    log.Fatalf("Gagal memperbarui pengguna: %v", err)
}

Anda juga dapat memperbarui beberapa bidang secara bersamaan:

a8m, err := a8m.Update().
    SetAge(30).                    // Memperbarui usia
    SetName("Ariel").              // Memperbarui nama
    AddRank(10).                   // Menambahkan peringkat sebesar 10
    Save(ctx)
if err != nil {
    log.Fatalf("Gagal memperbarui pengguna: %v", err)
}

Operasi pembaruan dapat dijadikan berantai, yang sangat fleksibel dan mudah dibaca. Memanggil metode Save akan melakukan pembaruan dan mengembalikan entitas yang diperbarui atau pesan kesalahan.

5.2 Pembaruan Berdasarkan Kondisi

Ent memungkinkan Anda untuk melakukan pembaruan berdasarkan kondisi-kondisi tertentu. Berikut adalah contoh di mana hanya pengguna yang memenuhi kondisi tertentu akan diperbarui.

// Mengasumsikan kita memiliki ‘id’ pengguna dan ingin menandai pengguna tersebut sebagai selesai untuk versi ‘currentVersion’

err := client.Todo.
    UpdateOneID(id).          // Membuat pembuat untuk memperbarui berdasarkan ID pengguna
    SetStatus(todo.StatusDone).
    AddVersion(1).
    Where(
        todo.Version(currentVersion),  // Operasi pembaruan hanya dieksekusi ketika versi saat ini cocok
    ).
    Exec(ctx)
switch {
case ent.IsNotFound(err):
    fmt.Println("Todo tidak ditemukan")
case err != nil:
    fmt.Println("Kesalahan pembaruan:", err)
}

Ketika menggunakan pembaruan berdasarkan kondisi, metode .Where() harus terlibat. Ini memungkinkan Anda untuk menentukan apakah pembaruan harus dilakukan berdasarkan nilai-nilai saat ini di dalam database, yang sangat penting untuk memastikan konsistensi dan integritas data.

6. Operasi Penghapusan Entitas

6.1 Menghapus Satu Entitas

Menghapus entitas merupakan fungsi penting lainnya dalam operasi database. Kerangka kerja Ent menyediakan API sederhana untuk melakukan operasi penghapusan.

Contoh berikut menunjukkan bagaimana menghapus entitas pengguna yang diberikan:

err := client.User.
    DeleteOne(a8m).  // Membuat pembuat penghapusan pengguna
    Exec(ctx)        // Melaksanakan operasi penghapusan
if err != nil {
    log.Fatalf("Gagal menghapus pengguna: %v", err)
}

6.2 Penghapusan Berdasarkan Kondisi

Mirip dengan operasi pembaruan, kita juga dapat melakukan operasi penghapusan berdasarkan kondisi-kondisi tertentu. Pada skenario tertentu, mungkin kita hanya ingin menghapus entitas yang memenuhi kondisi-kondisi spesifik. Menggunakan metode .Where() dapat menentukan kondisi-kondisi ini:

// Misalkan kita ingin menghapus semua file dengan waktu update lebih awal dari tanggal tertentu

affected, err := client.File.
    Delete().
    Where(file.UpdatedAtLT(date)).  // Hanya menjalankan penghapusan jika waktu update file lebih awal dari tanggal yang diberikan
    Exec(ctx)
if err != nil {
    log.Fatalf("Gagal menghapus file: %v", err)
}

// Operasi ini mengembalikan jumlah catatan yang terpengaruh oleh operasi penghapusan
fmt.Printf("%d file telah dihapus\n", affected)

Menggunakan operasi penghapusan berdasarkan kondisi memastikan kontrol yang tepat atas operasi data kita, memastikan bahwa hanya entitas-entitas yang benar-benar memenuhi kondisi yang dihapus. Hal ini meningkatkan keamanan dan keandalan operasi database.