MySQL

MySQL est la base de données relationnelle open source la plus populaire à l'heure actuelle. Les connaissances SQL spécifiques ne seront pas abordées en détail ici. Si vous ne les maîtrisez pas, veuillez d'abord les apprendre par vous-même. Cet article explique simplement comment utiliser Go pour effectuer des opérations SQL. Dans les projets, on n'utilise généralement pas directement le pilote pour les opérations de base de données, mais plutôt un framework ORM. Ici, nous utilisons la bibliothèque sqlx, qui est une amélioration de la bibliothèque standard sql. Elle n'a pas toutes les fonctionnalités d'un ORM mais reste simple et efficace. Si vous souhaitez utiliser un ORM, vous pouvez découvrir des bibliothèques comme Gorm, Xorm, Ent.

Dépendances

Téléchargez la bibliothèque sqlx

$ go get github.com/jmoiron/sqlx

sqlx ou la bibliothèque standard database/sql prend en charge plusieurs bases de données, pas seulement MySQL. Toute base de données implémentant l'interface driver.Driver est prise en charge, par exemple :

• PostgreSQL
• Oracle
• MariaDB
• SQLite
• Et d'autres bases de données relationnelles

Pour utiliser une base de données spécifique, vous devez implémenter un pilote de base de données. Le pilote peut être écrit par vous-même ou provenir d'une bibliothèque tierce. Avant utilisation, vous devez enregistrer le pilote avec sql.Register. Cependant, les bibliothèques de pilotes téléchargées enregistrent généralement automatiquement le pilote, vous n'avez donc pas besoin de le faire manuellement.

func Register(name string, driver driver.Driver)

MySQL étant très populaire et simple, cet article utilise MySQL pour les explications. Les opérations sur les autres bases de données relationnelles sont très similaires. Téléchargez le pilote MySQL

$ go get github.com/go-sql-driver/mysql

Se connecter à la base de données

Avec la fonction sqlx.Open, vous pouvez ouvrir une connexion à la base de données. Elle accepte deux paramètres : le premier est le nom du pilote, le second est la source de données (généralement appelée DSN).

func Open(driverName, dataSourceName string) (*DB, error)

Le nom du pilote doit correspondre à celui utilisé lors de l'enregistrement. Le DSN est l'adresse de connexion à la base de données, qui peut varier selon les bases de données. Pour MySQL, c'est comme suit :

db,err := sqlx.Open("mysql","root:123456@tcp(127.0.0.1:3306)/test")

Préparer les données

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  `age` tinyint(0) NULL DEFAULT NULL,
  `address` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('12132', '张三', 35, '北京市');
INSERT INTO `user` VALUES ('16162', '王五', 22, '上海市');

SET FOREIGN_KEY_CHECKS = 1;

Requêtes

Effectuer une requête et mapper le résultat dans une structure

var db *sqlx.DB

type Person struct {
   UserId   string `db:"id"`
   Username string `db:"name"`
   Age      int    `db:"age"`
   Address  string `db:"address"`
}

func init() {
    conn, err := sqlx.Open("mysql", "root:wyh246859@tcp(127.0.0.1:3306)/test")
   if err != nil {
      fmt.Println("Open mysql failed", err)
      return
   }

   db = conn
}

func main() {
   query()
   defer db.Close()
}

func query() {
   var person Person
   // Pour un résultat unique, utilisez Get ; pour plusieurs résultats, utilisez Select
   err := db.Get(&person, "select * from user where id = ?", "12132")
   if err != nil {
      fmt.Println("query failed:", err)
      return
   }
   fmt.Printf("query succ:%+v", person)
}

func list() {
  var perons []Person
  err := db.Select(&perons, "select * from user")
  if err != nil {
    fmt.Println("list err", err)
    return
  }
  fmt.Printf("list succ,%+v", perons)
}

Insertion

Insérer des données

func insert() {
   result, err := db.Exec("insert into user value (?,?,?,?)", "120230", "李四", 12, "广州市")
   if err != nil {
      fmt.Println("insert err:", err)
      return
   }
   id, err := result.LastInsertId()
   if err != nil {
      fmt.Println("insert err:", err)
      return
   }
   fmt.Println("insert succ:", id)
}

Mise à jour

Mettre à jour des données

func update() {
   res, err := db.Exec("update user set name = ? where id = ?", "赵六", "120230")
   if err != nil {
      fmt.Println("update err:", err)
      return
   }
   eff, err := res.RowsAffected()
   if err != nil || eff == 0 {
      fmt.Println("update err:", err)
      return
   }
   fmt.Println("Update succ")
}

Suppression

Supprimer des données

func delete() {
   res, err := db.Exec("delete from user where id = ?", "120230")
   if err != nil {
      fmt.Println("delete err:", err)
      return
   }
   eff, err := res.RowsAffected()
   if err != nil || eff == 0 {
      fmt.Println("delete err:", err)
      return
   }
   fmt.Println("delete succ")
}

Transactions

func (db *DB) Begin() (*Tx, error) // Démarrer une transaction
func (tx *Tx) Commit() error // Valider une transaction
func (tx *Tx) Rollback() error // Annuler une transaction

Lorsqu'une transaction est démarrée, par précaution, on ajoute toujours defer tx.Rollback(). Si une erreur survient pendant le processus, la transaction sera annulée. Si la transaction est validée avec succès, cette annulation n'aura aucun effet.

func main() {

  transation, err := db.Begin()
  if err != nil {
    fmt.Println("transation err")
  }
    defer transation.Rollback()

  insert()
  query()
  update()
  query()
  delete()
   transation.Commit()
}