importez les packages requis, puis préparez une structure avec le même schéma que dans l'exemple de la table tb_student dans la base de données, plus tard cette structure sera utilisée comme conteneur pour le résultat de la requête Type de données.

package main
import "fmt"
import "database/sql"
import _ "github.com/go-sql-driver/mysql"


type student struct {
 id string,
 name string,
 age int,
 grade int,
}

Le pilote de base de données utilisé doit être importé à l'aide du signe _, car même s'il est nécessaire au package base de données/sql, nous n'interagissons pas directement avec le pilote.

Ensuite, créez une fonction pour vous connecter à la base de données.

func connect() (*sql.DB, error) {
 db, err := sql.Open("mysql","root:@tcp(127.0.0.1:3306)/db_learn_go")
 if err != nil {
  return nil, err
 }
 return db, nil
}

Le schéma de chaîne de connexion pour le pilote MySQL que nous utilisons est assez unique, root@tcp(127.0.0.1:3306)/db_learn_go ci-dessous est un schéma de chaîne de connexion qui peut être utilisé lors de vos déplacements avec le pilote MYSQL Driver, si vous utilisez un autre mysql, le schéma de connexion peut être différent selon le pilote utilisé.

user:password@tcp(host:port)/dbname
user@tcp(host:port)/dbname

Vous trouverez ci-dessous une explication de la chaîne de connexion utilisée dans la fonction connect().

root@tcp(127.0.0.1:3306)/db_learn_go
// user => root
// password =>
// host => 127.0.0.1 atau localhost
// port => 3306
// dbname => db_learn_go

Une fois la fonction de connectivité avec la base de données créée, il est temps de pratiquer le processus de lecture des données du serveur de base de données. Préparer la fonction
sqlQuery() avec le code suivant.

func sqlQuery() {
 db, err := connect()
 if err != nil {
 fmt.Println(err.Error())
 return
 }
 defer db.Close()
 var age = 27
 rows, err := db.Query("select id, name, grade from tb_student where age = ?
 if err != nil {
 fmt.Println(err.Error())
 return
 }
 defer rows.Close()
 var result []student
 for rows.Next() {
 var each = student{}
 var err = rows.Scan(&each.id, &each.name, &each.grade)
 if err != nil {
 fmt.Println(err.Error())
 return
 }
 result = append(result, each)
 }
 if err = rows.Err(); err != nil {
 fmt.Println(err.Error())
 return
 }
 for _, each := range result {
 fmt.Println(each.name)
 }
}

A chaque fois qu'une nouvelle connexion est créée, n'oubliez pas de toujours fermer l'instance de connexion. Vous pouvez utiliser le mot-clé defer comme dans le code ci-dessus, defer
db.Close() .
La fonction db.Query() est utilisée pour exécuter des requêtes SQL. Le deuxième paramètre de la fonction est variadique, il peut donc rester vide. Dans le code ci-dessus, vous pouvez voir que la valeur de l'une des clauses Where est un point d'interrogation (?).

Le signe sera alors remplacé par la valeur du paramètre qui le suit (la valeur de la variable age). Ce type de technique d’écriture de requêtes est fortement recommandé pour éviter l’injection SQL. La fonction produit une instance de type sql.*Rows , qui doit également être fermée lorsqu'elle n'est plus utilisée ( defer rows.Close() ). Ensuite, un tableau avec le type d'élément struct student est préparé avec le nom result . Plus tard, les résultats de la requête seront stockés dans la variable. Ensuite, une boucle est effectuée avec la référence de condition étant rows.Next() . Cette boucle est exécutée autant de fois que le nombre total d'enregistrements, séquentiellement du premier enregistrement à la fin, un par un. La méthode Scan() de sql.Rows fonctionne pour récupérer la valeur de l'enregistrement en cours d'itération, à stocker dans une variable de pointeur. Les variables utilisées pour stocker les champs d'enregistrement sont écrites séquentiellement sous forme de paramètres variadiques, en fonction des champs sélectionnés dans la requête. Veuillez consulter la comparaison ci-dessous pour plus de détails. // requête
sélectionnez l'identifiant, le nom, le grade ...
// analyse
rows.Scan(&each.id, &each.name, &each.grade ...
Les données d'enregistrement obtenues sont ensuite ajoutées à la tranche de résultat, via l'instruction
résultat = ajouter (résultat, chacun) .
OK, maintenant appelez simplement la fonction sqlQuery() dans main , puis exécutez le programme.

func main() {
sqlQuery()
}

Je ne suis qu'un blogueur ordinaire. S'il y a encore trop de défauts, pardonnez-moi.