Comment mapper efficacement les relations de base de données un-à-plusieurs et plusieurs-à-plusieurs avec des structures dans Go ?

Mappage efficace des relations de base de données un-à-plusieurs et plusieurs-à-plusieurs avec des structures dans Go

Contexte< ;/h2>

Lorsque vous travaillez avec une base de données, il est courant de rencontrer des relations un-à-plusieurs et plusieurs-à-plusieurs. Dans de tels scénarios, un mappage efficace et évolutif de ces relations avec les structures Go est crucial.

Approche recommandée utilisant les agrégateurs de tableaux PostgreSQL et GROUP BY

Une approche efficace consiste tirant parti des agrégateurs de tableaux de PostgreSQL et de la fonctionnalité GROUP BY. Cela implique la création d’une vue qui regroupe les éléments et leurs données associées à l’aide d’une agrégation de tableaux. La vue résultante peut ensuite être interrogée, avec le contenu du tableau non organisé dans une structure Go.

<br>sql := `<br>CREATE VIEW item_tags AS<br>SELECT<br> id ,<br> ARRAY_AGG(ROW_TO_JSON(taglist.*)) AS tags<br>FROM<br> (</p>
<pre class="brush:php;toolbar:false">SELECT
  tag.name,
  tag.id
FROM
  tag
WHERE
  item_id = item.id

) AS taglist
GROUP BY
item.id
`
db.MustExec(sql)

Le code Go serait alors :

<br>type Item struct {<br> ID int<br> Tags []Tag<br>}</p>
<p>lignes, err := db.Queryx("SELECT row_to_json(row) FROM (SELECT * FROM item_tags) row")<br>pour les lignes. Next() {<br> var item Item<br> var jsonString string<br> if err := rows.Scan(&jsonString); err != nil {</p>
<pre class="brush:php;toolbar:false">return err

}
if err := json.Unmarshal([]byte(jsonString), &item); err != nul {

return err

}
items = append(items, item)
}

Avantages< /h2>

Cette approche combine la flexibilité de PostgreSQL avec l'efficacité de l'agrégation de tableaux et du marshalling au niveau des lignes dans Go. Elle évolue de manière transparente, même avec des relations complexes.

Alternatives

Bien que l'approche recommandée soit efficace et polyvalente, les solutions alternatives mentionnées dans la question ont leurs propres atouts et faiblesses :

• Approche 1 (requêtes multiples) : Simple mais inefficace pour les grands ensembles de données.
• Approche 2 (bouclage manuel) : Moins gourmand en mémoire mais complexe et sujet aux erreurs.
• Échec de l'approche 3 (Struct Scanning) : Théoriquement idéal mais non pris en charge par SQLx.
• Approche possible 4 (Matrices PostgreSQL) :Non testé mais potentiellement non viable.

En fin de compte, la meilleure approche dépend des exigences spécifiques de l'application et des technologies disponibles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!