Bagaimanakah anda boleh memetakan perhubungan pangkalan data satu-ke-banyak dan banyak-ke-banyak dengan cekap kepada struct Go?

Memetakan Satu-ke-Banyak dan Banyak-ke-Banyak Hubungan Pangkalan Data dengan Cekap kepada Structs in Go

Apabila bekerja dengan perhubungan pangkalan data yang kompleks, memetakannya dengan cekap kepada struct Go adalah penting untuk mengekalkan prestasi dan kebolehselenggaraan kod. Berikut ialah beberapa pendekatan dan pertimbangannya:

Pendekatan 1: Pilih Semua Item, Kemudian Pilih Tag Setiap Item

Pendekatan ini mudah tetapi tidak cekap, kerana ia memerlukan pertanyaan berasingan untuk setiap item mengambil teg berkaitannya. Walaupun ia mungkin berfungsi dengan baik untuk set data kecil, ia menjadi mahal untuk set data yang lebih besar.

Pendekatan 2: Bina SQL Join dan Gelung Melalui Baris Secara Manual

Pendekatan ini menggunakan satu pertanyaan pangkalan data dengan gabungan untuk mendapatkan semula data berkaitan. Walaupun ia menghapuskan prestasi prestasi berbilang pertanyaan, ia boleh menyusahkan untuk dibangunkan dan diselenggara, terutamanya untuk pertanyaan kompleks dengan berbilang gabungan.

Pendekatan 3: Pengagregat Array PostgreSQL dan KUMPULAN OLEH

Pendekatan ini memanfaatkan agregator tatasusunan PostgreSQL untuk mengumpulkan dan mengagregatkan data berkaitan ke dalam tatasusunan. Walaupun ia bukan penyelesaian langsung untuk memetakan struct Go, ia boleh meningkatkan prestasi dengan ketara untuk set data yang besar.

Penyelesaian Alternatif: Menggunakan Paparan Postgres

Pendekatan alternatif yang menangani batasan kaedah sebelumnya melibatkan mencipta pandangan Postgres yang mengembalikan struktur data yang dikehendaki. Paparan boleh melakukan cantuman dan pengagregatan yang diperlukan, membolehkan mendapatkan semula data berkaitan yang cekap.

Dalam contoh yang disediakan, SQL berikut boleh mencipta paparan bernama item_tags:

create view item_tags as
select id,
  (
          select
            array_to_json(array_agg(row_to_json(taglist.*))) as array_to_json
          from (
                select tag.name, tag.id
                 from tag
                         where item_id = item.id
               ) taglist ) as tags
from item ;

Untuk memetakan pandangan kepada struct Go, anda boleh melaksanakan pertanyaan berikut dan menyahmarshal hasilnya:

type Item struct {
  ID    int
  Tags  []Tag
}

type Tag struct {
  ID    int
  Name  string
}

func main() {
  // Execute the query to fetch the data from the view
  rows, err := sql.Query("select  row_to_json(row)\nfrom (    select * from item_tags\n) row;")
  if err != nil {
    // Handle error
  }

  // Iterate through the rows and unmarshal the data
  for rows.Next() {
    var item Item
    var data []byte
    if err := rows.Scan(&data); err != nil {
      // Handle error
    }

    if err := json.Unmarshal(data, &item); err != nil {
      // Handle error
    }

    fmt.Println(item)
  }
}

Pendekatan ini memberikan faedah berikut:

• Pendapatan data yang cekap: Paparan boleh melakukan cantuman dan pengagregatan yang diperlukan, menghasilkan satu pertanyaan yang cekap.
• Struktur pemetaan untuk Pergi yang mudah: Dengan mengembalikan data dalam format JSON, pemetaan ke Struk Go menjadi mudah menggunakan fungsi json.Unmarshal.
• Kebolehselenggaraan: Logik pangkalan data dirangkumkan dalam paparan, menjadikannya lebih mudah untuk menyelenggara dan menggunakan semula merentas aplikasi yang berbeza.

Atas ialah kandungan terperinci Bagaimanakah anda boleh memetakan perhubungan pangkalan data satu-ke-banyak dan banyak-ke-banyak dengan cekap kepada struct Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!