Cómo usar Golang con MySQL

Cómo usar Go con MySQL

  • Instala el controlador de Go para MySQL: go get -u github.com/go-sql-driver/mysql.
  • Conéctate a tu base de datos usando sql.Open y prueba con db.Ping.
  • Usa db.Query, db.Exec y db.Scan para operaciones de inserción, lectura, actualización y eliminación.
  • Asegúrate de que tu servidor MySQL esté funcionando y de que tu cadena de conexión sea correcta.
  • Utiliza CodeRunner para escribir y probar tu código en Go, SnippetsLab para organizar fragmentos, Secrets 4 para guardar contraseñas de forma segura y TablePlus para administrar bases de datos fácilmente.

¿Buscas la mejor base de datos para usar con tus proyectos en Golang? MySQL es una de las herramientas más populares para trabajar con bases de datos SQL. ¿Es la mejor opción para ti? La única forma de saberlo es probándola.

En este artículo, te guiaré paso a paso para conectarte a bases de datos MySQL usando Go, configurar tu entorno para una integración fluida y ejecutar operaciones básicas de bases de datos con ejemplos prácticos de Go + MySQL.

Introducción al controlador Go MySQL

Estos son los primeros pasos que debes seguir:

  1. Asegúrate de tener MySQL en tu máquina ejecutando el comando mysql --version en la Terminal.
  2. Si tienes MySQL instalado, verás impresa la versión de MySQL en la ventana de tu Terminal.
  3. A continuación, ejecuta el comando de instalación para el controlador de Golang MySQL: go get -u github.com/go-sql-driver/mysql.

No es obligatorio usar este controlador específico de Go para MySQL, pero es uno de los más populares, por eso lo utilizaremos en este tutorial. Puedes encontrar información detallada sobre este controlador en su página de GitHub.

Ahora, conectemos MySQL.

Ahora, conectemos MySQL

Crea tu aplicación en la carpeta donde tengas todos tus archivos de instalación de Golang, o ejecuta: 

  • go mod init test-sql
  • go mod tidy

Esto te permitirá ejecutar tu aplicación Go en una carpeta diferente de aquella donde tienes instalado Go.

Con esto listo, ya estás preparado para conectarte. Crea un archivo main.go e inserta el siguiente código:

package main
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
func main() {
    // Replace 'yourpassword' with your actual MySQL root password
    dsn := "root:yourpassword@tcp(127.0.0.1:3306)/test"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
    // Verify the connection is valid
    err = db.Ping()
    if err != nil {
        panic(err.Error())
    }
    fmt.Println("Success!")
}

Asegúrate de que la base de datos de prueba exista en tu servidor MySQL. Si no existe, puedes crearla usando la interfaz de línea de comandos de MySQL: CREATE DATABASE test;.

Puedes escribir este código en cualquier editor de código que prefieras. Yo uso CodeRunner, un editor rápido con prácticos resaltadores de sintaxis, características de IDE y compatibilidad con más de 25 lenguajes, incluido Golang. Simplemente copia el código anterior e inserta tu contraseña de base de datos MySQL en esta línea:

“root:@tcp(127.0.0.1:3306)/test”).

Una vez hecho esto, estarás listo para ejecutar tu aplicación Go en la Terminal. Primero, mueve a la carpeta que contiene tu programa main.go utilizando el comando de cambio de directorio cd:

Después, escribe go run main.go. Tu programa imprimirá “¡Éxito!” en la pantalla si todo funciona correctamente.

Consejo personal

Recomiendo guardar el fragmento de código en SnippetsLab, una aplicación que ayuda a organizar tus fragmentos de código. Solo asegúrate de guardar el código sin tus credenciales de inicio de sesión. Usa un administrador de contraseñas para mantener tu información segura. Guardé mi contraseña de base de datos MySQL en Secrets 4. Esta aplicación te permite organizar y mantener seguras contraseñas, notas sensibles, información de tarjetas de crédito, detalles de cuentas bancarias y más.

Conectar tu aplicación Go a MySQL

Para conectar tu aplicación Go a MySQL:

  1. Crea una nueva carpeta de proyecto Go si aún no tienes una.
  2. Agrega el paquete go-sql-driver/mysql a tu proyecto Go utilizando go get -u github.com/go-sql-driver/mysql. Si estás usando un sistema de base de datos diferente, ajusta el nombre del driver (la parte “mysql”) según corresponda. 
  3. Escribe un programa Go para conectarte a MySQL utilizando este código:
import (
    "database/sql"
    "fmt"
    "log"
    "github.com/go-sql-driver/mysql"
)
func main() {
    cfg := mysql.Config{
        User:                 "user",
        Passwd:               "password",
        Net:                  "tcp",
        Addr:                 "localhost:3306",
        DBName:               "database",
        AllowNativePasswords: true,
    }
    db, err := sql.Open("mysql", cfg.FormatDSN())
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    if err = db.Ping(); err != nil {
        log.Fatal(err)
    }
    fmt.Println("Successfully connected to MySQL!")
}

4. Reemplaza user:password\@tcp(host:port)/database con los detalles de tu conexión MySQL.

5. Guarda el código en un archivo ejecutable y ejecútalo usando el comando go run main.go.

Para conectar tu aplicación en Go a MySQL con éxito, asegúrate de que tu cliente MySQL esté correctamente instalado y configurado. Gestiona las dependencias en tu proyecto Go utilizando módulos de Go, implementa un manejo de errores completo y utiliza métodos seguros para almacenar y transmitir credenciales de MySQL.

Configurando tu base de datos MySQL para Golang

Antes de configurar tu base de datos MySQL para Golang, primero necesitas instalar MySQL siguiendo estos pasos:

  1. Descarga el paquete de instalación desde el sitio web oficial de MySQL.
  2. Abre el paquete y sigue las instrucciones del asistente de instalación.
  3. Establece una contraseña para el usuario root si se te solicita.
  4. Cierra el asistente una vez que la instalación haya finalizado.

También puedes instalar MySQL utilizando Homebrew si tienes un Mac. Simplemente abre Terminal y escribe el comando brew install mysql. Para verificar la instalación de MySQL, escribe el comando mysql –version en Terminal y utiliza el comando mysql -u root -p para empezar a usar el servidor.

Consejo

Antes de aprender a usar Golang para insertar en tu base de datos SQL, primero creemos una base de datos inicial. Hay varias formas de hacerlo, una de las cuales es utilizando Docker. Para este artículo, elegí una solución sin código ofrecida por TablePlus. La aplicación te permite crear, gestionar y consultar bases de datos en MySQL, PostgreSQL y SQLite.

Creé una base de datos para las consultas de Golang titulada 123begin. Luego, creé una tabla titulada testtable2. Recuerda estos valores porque los necesitarás para insertar y consultar tu base de datos.

Trabajando con una base de datos MySQL

Ahora que tenemos nuestra tabla, intentemos insertar algunos datos: un objeto en la base de datos.

Aquí está el código para insertar un objeto en una tabla de tu base de datos:

package main
import (
    "fmt"
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)
func main() {
    db, err := sql.Open("mysql", "root:<password>@tcp(127.0.0.1:3306)/123begin")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
    insert, err := db.Query("INSERT INTO testtable2 VALUES('23')")
    if err !=nil {
        panic(err.Error())
    }
    defer insert.Close()
    fmt.Println("Yay, values added!")
}

Agrega este código a tu archivo main.go. Puedes copiar tu código anterior a SnippetsLab para acceder a él en otros proyectos.

Ahora, ejecuta el comando go run main.go en la Terminal dentro de la carpeta de tu proyecto en Go. Si todo sale bien, deberías ver impreso ¡Yay, valores añadidos!:

Con el nuevo valor añadido, podemos hacer que una aplicación en Golang realice una consulta SQL a la base de datos para verificar que el valor se haya añadido correctamente a la tabla.

Aquí está el código que utilicé para esto:

package main
import (
    "fmt"
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)
type Testtable2 struct {
    id int `json:"id"`
}
func main() {
    db, err := sql.Open("mysql", "root:<password>@tcp(127.0.0.1:3306)/123begin")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
    results, err := db.Query("SELECT id FROM testtable2")
    if err !=nil {
        panic(err.Error())
    }
    for results.Next() {
        var testtable2 Testtable2
        err = results.Scan(&testtable2.id)
        if err !=nil {
            panic(err.Error())
        }
        fmt.Println(testtable2.id)
    }
}

Reemplace testtable2, 123begin e id con los valores correspondientes para su tabla de base de datos, nombre de base de datos y la columna que está consultando.

Ejecute go run main.go en la Terminal:

Tenemos 23 impreso de vuelta, que es el valor que hemos insertado en nuestra tabla en el paso anterior, por lo que nuestra consulta ha sido un éxito.

Ejecutando consultas SQL en Golang

A continuación, te mostraré cómo hacerlo.

Operación de inserción

Para insertar un objeto en tu tabla MySQL usando Go:

  1. Agrega este código a tu archivo main.go:
package main
import (
    "fmt"
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)
func main() {
    db, err := sql.Open("mysql", "root:<password>@tcp(127.0.0.1:3306)/123begin")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
    insert, err := db.Query("INSERT INTO testtable2 VALUES('23')")
    if err !=nil {
        panic(err.Error())
    }
    defer insert.Close()
    fmt.Println("Yay, values added!")
}

2. Ejecuta main.go en la Terminal, y recibirás la línea “Yay, values added” o lo que hayas reemplazado si todo funciona correctamente.

Solo un recordatorio: 23 es el valor que añadimos a la tabla de la base de datos.

Operación de lectura

Para leer valores en una tabla MySQL usando Go:

  1. Agrega este código a tu archivo main.go:
package main
import (
    "fmt"
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)
type Testtable2 struct {
    id int `json:"id"`
}
func main() {
    db, err := sql.Open("mysql", "root:<password>@tcp(127.0.0.1:3306)/123begin")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
    results, err := db.Query("SELECT id FROM testtable2")
    if err !=nil {
        panic(err.Error())
    }
    for results.Next() {
        var testtable2 Testtable2
        err = results.Scan(&testtable2.id)
        if err !=nil {
            panic(err.Error())
        }
        fmt.Println(testtable2.id)
    }
}

2. Reemplaza testtable2, 123begin y id con los valores correspondientes a tu tabla de base de datos, nombre de base de datos y la columna que deseas leer.

3. Ejecuta main.go en la Terminal, y recibirás los valores en los campos de la tabla referenciados si todo está hecho correctamente.

En este caso, el valor devuelto es 23, ya que es lo que se insertó en la tabla.

Operación de actualización

Para actualizar una tabla MySQL usando Go:

  1. Agrega este código a tu archivo main.go:
package main
import (
    "database/sql"
    "fmt"
    "log"
    _ "github.com/go-sql-driver/mysql"
)
func main() {
    // Replace with your actual DB credentials
    dsn := "username:password@tcp(127.0.0.1:3306)/yourdbname"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatalf("Error opening DB: %v", err)
    }
    defer db.Close()
    // Check DB connection
    if err := db.Ping(); err != nil {
        log.Fatalf("Error pinging DB: %v", err)
    }
    // Example: Update user email where user_id = ?
    query := "UPDATE users SET email = ? WHERE user_id = ?"
    // Parameters
    newEmail := "[email protected]"
    userID := 1
    // Execute the query
    result, err := db.Exec(query, newEmail, userID)
    if err != nil {
        log.Fatalf("Error updating record: %v", err)
    }
    // Affected rows
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        log.Fatalf("Error getting rows affected: %v", err)
    }
    fmt.Printf("Update successful, %d row(s) affected.n", rowsAffected)
}

2. Reemplaza users, email y user_id con los nombres de tu tabla y columnas.

3. Ejecuta main.go en la Terminal.

Si todo está correcto, los campos de la tabla mencionados en el código deberían actualizarse según las instrucciones.

Operación de eliminación

Para eliminar una fila de una tabla MySQL usando Go:

  1. Agrega este código a tu archivo main.go:
package main
import (
    "database/sql"
    "fmt"
    "log"
    _ "github.com/go-sql-driver/mysql"
)
func main() {
    // Replace with your actual DB credentials
    dsn := "username:password@tcp(127.0.0.1:3306)/yourdbname"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatalf("Failed to connect to DB: %v", err)
    }
    defer db.Close()
    // Test the connection
    if err := db.Ping(); err != nil {
        log.Fatalf("Failed to ping DB: %v", err)
    }
    // DELETE statement with placeholder
    query := "DELETE FROM users WHERE user_id = ?"
    // ID of the row to delete
    userID := 1
    // Execute the DELETE query
    result, err := db.Exec(query, userID)
    if err != nil {
        log.Fatalf("Failed to delete record: %v", err)
    }
    // Check how many rows were affected
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        log.Fatalf("Failed to retrieve affected rows: %v", err)
    }
    fmt.Printf("Successfully deleted %d row(s)n", rowsAffected)
}

2. Ejecuta main.go en la Terminal.

Si todo está configurado correctamente, la fila especificada será eliminada de la tabla.

Lee también:

  • Gestiona múltiples bases de datos con TablePlus
  • Dbms para Mac

Problemas con el controlador Go MySQL

Al escribir código, es fácil cometer errores tipográficos o comandos incorrectos.

Uno de los errores más comunes es ejecutar go run main.go en la carpeta equivocada. Asegúrate de estar dentro de la carpeta que contiene tu proyecto Go, de lo contrario, la aplicación no se ejecutará.

Usa el comando cd (cambiar directorio) para navegar a la carpeta correcta. Un truco rápido: simplemente arrastra y suelta la carpeta en la ventana de tu Terminal después de escribir cd, luego presiona Enter.

Además, tu aplicación Go no funcionará sin go.mod y go.sum. Ejecuta el comando ls en la Terminal para verificar que ambos archivos estén en tu carpeta. Si faltan, créalos utilizando los comandos mencionados en la sección de primeros pasos anteriormente.

Y si crees que te has encontrado con un verdadero error de MySQL, puedes informarlo directamente en la página oficial de informes de errores de MySQL.

Reflexiones finales sobre cómo usar Go con MySQL

En este tutorial, te guié sobre cómo conectar tu aplicación Golang a una base de datos MySQL utilizando el controlador Go MySQL. Cubrí desde cómo configurar tu base de datos e instalar el controlador hasta realizar operaciones básicas de SQL como insertar, leer, actualizar y eliminar, todo con ejemplos prácticos. Ahora deberías sentirte seguro creando aplicaciones Go que interactúen sin problemas con MySQL.

A lo largo del camino, utilicé algunas herramientas que facilitaron y agilizaron el proceso. Escribí y probé el código en CodeRunner, organicé mis fragmentos con SnippetsLab, almacené credenciales de bases de datos de forma segura usando Secrets 4 y gestioné mis bases de datos con TablePlus. Estas herramientas ayudaron a optimizar el flujo de trabajo y también pueden ayudarte a ti.

Todas estas aplicaciones están disponibles a través de Setapp, una plataforma de productividad integral para usuarios de Mac. Con Setapp, tienes acceso a más de 260 aplicaciones potentes para desarrollo, gestión del tiempo, organización de archivos y más. Puedes probarlo gratis durante 7 días y ver cómo se adapta a tu flujo de trabajo.

Preguntas frecuentes

¿Cómo instalo MySQL para Golang?

Para instalar MySQL para Golang, abre el paquete descargado desde el sitio web oficial de MySQL y sigue las instrucciones del asistente de instalación.

¿Cuál es el mejor controlador Go MySQL?

El mejor controlador Go MySQL es go-sql-driver/mysql. Es el controlador MySQL más utilizado para Golang, ya que es ligero, rápido y no depende de enlaces C para su implementación nativa en Go. Permite conexiones a través de TCP/IPv4, sockets Unix y TCP/IPv6, mientras gestiona automáticamente el agrupamiento de conexiones y las conexiones interrumpidas.

¿Cómo inserto datos en MySQL usando Golang?

Para insertar datos en MySQL usando Golang, añade este código a tu archivo Go main.go y ejecútalo en la Terminal ingresando:

go run main.go: 
package main
import (
    "fmt"
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)
func main() {
    db, err := sql.Open("mysql", "root:<password>@tcp(127.0.0.1:3306)/123begin")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
    insert, err := db.Query("INSERT INTO testtable2 VALUES('23')")
    if err !=nil {
        panic(err.Error())
    }
    defer insert.Close()
    fmt.Println("Values to add")
}

Cuando ejecutes el archivo Go, debería devolver “Valores para agregar” o lo que hayas sustituido.

¿Por qué falla mi conexión Golang–MySQL?

Tu conexión Golang–MySQL podría estar fallando porque el servidor MySQL no está en funcionamiento o no es accesible, hay errores en los nombres de la base de datos o valores de conexión, o las rutas de tus archivos y carpetas son incorrectas o están rotas.

Share

You may also like...