Go: MySQL with Gorm

  • Go
  • Gabriele Romanato

Managing a MySQL database in a Go application can be a crucial part of software development. MySQL is one of the world's most popular relational databases, and is often chosen for its reliability, scalability, and robustness. To make working with MySQL in Go easier, you can use an ORM (Object-Relational Mapping) like Gorm. Gorm is a very popular ORM for Go that greatly simplifies database interaction, allowing you to focus on application logic instead of writing complex SQL queries.

Installing Gorm

To start using Gorm, you need to install it in your Go project. Run the following command to get the Gorm library:


go get -u github.com/go-gorm/gorm

Also, you need to install a MySQL driver for Gorm. The most commonly used MySQL driver is "github.com/go-sql-driver/mysql".


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

Connection to MySQL Database

Once Gorm and the MySQL driver are installed, you can connect to the MySQL database. Here's an example of how to do it:


     package main

     import (
         "fmt"
         "gorm.io/drivers/mysql"
         "gorm.io/gorm"
     )
    
     func main() {
         // DSN (Data Source Name) for connecting to the MySQL database
         dsn := "username:password@tcp(127.0.0.1:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local"
    
         // Open the connection to the MySQL database
         db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
         if err != nil {
             panic("Unable to connect to database")
         }
         defer db.Close()
    
         // You can now use 'db' to interact with the MySQL database
         fmt.Println("Database connection successful!")
     }

Remember to replace "username", "password" and "database_name" with your MySQL database login credentials.

Definition of Data Models

Before you can perform CRUD (Create, Read, Update, Delete) operations on the database, you need to define data models. Models represent database tables. Here is an example of how to define a data model using Gorm:


     package main

     import (
         "gorm.io/gorm"
     )
    
     // Definition of the data model
     type User struct {
         gorm. Model
         Username string
         Email string
     }

In this example, we defined a User template with three fields: ID, Username and Email. gorm.Model automatically provides the ID, CreatedAt, UpdatedAt and DeletedAt fields for the management of CRUD operations.

Performing CRUD Operations

Once the data model is defined, you can perform CRUD operations on the MySQL database using Gorm. Here are some examples of how to do this:

Creating a Record


     user := User{Username: "john_doe", Email: "john@example.com"}
     db.Create(&user)

Record Reading


     var user User
     db.First(&user, 1) // Read the first record with ID = 1
     db.Find(&user, "username = ?", "john_doe") // Read a record with Username = "john_doe"

Updating a Record


     db.Model(&user).Update("Email", "new_email@example.com")

Deleting a Record


     db.Delete(&user)

Managing Database Migrations

Gorm also simplifies the management of database migrations, which are critical during application development and evolution. Migrations allow you to define and apply database schema changes in a controlled way.

Here is an example of how to create a migration for the User model: 


     package main

     import (
         "gorm.io/gorm"
     )
    
     func main() {
         // Apply migrations for the User model
         db.AutoMigrate(&User{})
     }

This example will use Gorm to automatically create a table in the MySQL database matching the User pattern. If the database already exists, only the migrations needed to update the schema will be applied.

In conclusion, Gorm is a powerful and efficient library for managing a MySQL database in Go. It allows you to focus on the application logic without having to manually write complex SQL queries. With the connection to the database, the definition of the models for data, performing CRUD operations, and managing migrations, you're ready to start building robust, scalable applications with Go and MySQL.

Back to top