MySQL is one of the most widely used relational database systems, while Go is a fast, efficient programming language commonly used for backend development, REST APIs, microservices, and web applications.

If you are building a Go backend that needs to store users, products, orders, payments, posts, or other structured data, connecting your application to MySQL is an important skill.

Go provides the standard database/sql package for SQL database programming. To communicate specifically with MySQL, you also need a MySQL database driver.

In this guide, you will learn how to connect MySQL with Go, install the MySQL driver, create a database and user, configure a DSN, verify the connection, use environment variables, execute basic queries, configure connection pooling, handle common errors, and follow production best practices.

What Do You Need to Connect MySQL with Go?

You need three main components:

Go Application
      |
      v
database/sql
      |
      v
MySQL Driver
      |
      v
MySQL Database

Go provides database/sql, but it does not include a MySQL driver itself.

For this guide, we will use:

github.com/go-sql-driver/mysql

Why Use MySQL with Go?

MySQL is a popular choice for applications that require relational data.

It provides features such as:

SQL queries
transactions
indexes
joins
foreign keys
constraints
ACID-compliant storage engines such as InnoDB
replication
broad hosting support

Go complements MySQL with:

excellent backend performance
concurrency support
static typing
simple deployment
built-in database/sql
connection pooling
context and timeout support

This combination can be used for REST APIs, web applications, SaaS platforms, e-commerce systems, dashboards, and microservices.

Step 1: Install MySQL

Before connecting Go to MySQL, make sure MySQL Server is installed.

Check your installation:

mysql --version

You should see the installed MySQL version.

If the command is unavailable, install MySQL Server first.

Step 2: Start MySQL

How you start MySQL depends on your operating system.

On macOS with Homebrew, you may use:

brew services start mysql

On Linux with systemd:

sudo systemctl start mysql

On Windows, MySQL can normally be started through Windows Services or MySQL Installer.

Step 3: Log In to MySQL

Open the MySQL command-line client:

mysql -u root -p

Enter the root password when prompted.

After successful login, you should see the MySQL prompt:

mysql>

Step 4: Create a MySQL Database

Create a database for your Go application:

CREATE DATABASE go_app;

Check available databases:

SHOW DATABASES;

Select your database:

USE go_app;

Step 5: Create a Dedicated MySQL User

Using the root account from your application is generally not recommended.

Create a dedicated user instead:

CREATE USER 'go_user'@'localhost'
IDENTIFIED BY 'your_password';

Grant access to the application database:

GRANT ALL PRIVILEGES
ON go_app.*
TO 'go_user'@'localhost';

Apply privileges:

FLUSH PRIVILEGES;

For production systems, grant only the permissions the application actually needs.

Step 6: Create a Go Project

Create a project:

mkdir go-mysql

Enter the directory:

cd go-mysql

Initialize the Go module:

go mod init go-mysql

Create:

main.go

Project structure:

go-mysql/
│
├── go.mod
└── main.go

Step 7: Install the MySQL Driver

Install the popular Go MySQL driver:

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

Your Go application can now use MySQL through database/sql.

Step 8: Import `database/sql` and the MySQL Driver

Add:

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

Notice:

_ "github.com/go-sql-driver/mysql"

The underscore means the package is imported for its initialization side effects.

The driver registers itself with database/sql.

You do not need to call its functions directly when using the standard database/sql interface.

Step 9: Understand the MySQL DSN

MySQL commonly uses a DSN—Data Source Name—to describe the connection.

A basic DSN looks like:

username:password@tcp(host:port)/database

Example:

go_user:your_password@tcp(127.0.0.1:3306)/go_app

Breaking it down:

go_user
→ MySQL username

your_password
→ MySQL password

tcp
→ network protocol

127.0.0.1
→ MySQL server

3306
→ MySQL port

go_app
→ database

The default MySQL TCP port is:

Step 10: Connect MySQL with `sql.Open`

Create a database handle:

dsn :=
    "go_user:your_password@tcp(127.0.0.1:3306)/go_app"

db, err :=
    sql.Open(
        "mysql",
        dsn,
    )

if err != nil {
    log.Fatal(err)
}

defer db.Close()

The driver name is:

"mysql"

Important: `sql.Open()` Does Not Guarantee a Connection

A common beginner mistake is assuming that:

sql.Open()

immediately establishes and verifies a database connection.

sql.Open() creates a database handle that manages a connection pool.

The actual connection may be established later.

Therefore, verify connectivity using:

db.Ping()

Step 11: Verify the MySQL Connection

Add:

err = db.Ping()

if err != nil {
    log.Fatal(err)
}

fmt.Println(
    "Connected to MySQL successfully",
)

Complete MySQL Connection Example

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

func main() {
    dsn :=
        "go_user:your_password@tcp(127.0.0.1:3306)/go_app"

    db, err :=
        sql.Open(
            "mysql",
            dsn,
        )

    if err != nil {
        log.Fatal(err)
    }

    defer db.Close()

    if err :=
        db.Ping();
        err != nil {

        log.Fatal(err)
    }

    fmt.Println(
        "Connected to MySQL successfully",
    )
}

Run:

go run main.go

Expected output:

Connected to MySQL successfully

Step 12: Use `PingContext`

For backend applications, using context is usually better than a plain Ping().

Import:

"context"
"time"

Create a timeout:

ctx, cancel :=
    context.WithTimeout(
        context.Background(),
        5*time.Second,
    )

defer cancel()

Then:

if err :=
    db.PingContext(ctx);
    err != nil {

    log.Fatal(err)
}

This prevents your application from waiting indefinitely when the database cannot be reached.

Complete Connection with Timeout

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "time"

    _ "github.com/go-sql-driver/mysql"
)

func main() {
    dsn :=
        "go_user:your_password@tcp(127.0.0.1:3306)/go_app"

    db, err :=
        sql.Open(
            "mysql",
            dsn,
        )

    if err != nil {
        log.Fatal(err)
    }

    defer db.Close()

    ctx, cancel :=
        context.WithTimeout(
            context.Background(),
            5*time.Second,
        )

    defer cancel()

    if err :=
        db.PingContext(ctx);
        err != nil {

        log.Fatal(
            "MySQL connection failed:",
            err,
        )
    }

    fmt.Println(
        "MySQL connection successful",
    )
}

Step 13: Store MySQL Credentials in Environment Variables

Hardcoding database credentials is not recommended.

Avoid production code like:

dsn :=
    "root:password123@tcp(localhost:3306)/go_app"

Instead, use an environment variable:

DATABASE_DSN

Import:

"os"

Then:

dsn :=
    os.Getenv(
        "DATABASE_DSN",
    )

if dsn == "" {
    log.Fatal(
        "DATABASE_DSN is required",
    )
}

Set the Environment Variable

On macOS or Linux:

export DATABASE_DSN="go_user:your_password@tcp(127.0.0.1:3306)/go_app"

Then run:

go run main.go

Using a `.env` File

During local development, you may choose to keep configuration in a .env file:

DATABASE_DSN=go_user:your_password@tcp(127.0.0.1:3306)/go_app

A .env file is not automatically loaded by Go’s standard library.

You can either export the variables through your shell or use a configuration library if your project requires .env loading.

If the file contains secrets, add:

.env

to:

.gitignore

Never commit real production credentials to a public repository.

Step 14: Create a MySQL Table

Connect to:

USE go_app;

Create a users table:

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(150) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Check:

DESCRIBE users;

Step 15: Test MySQL with a Simple Query

You can test the connection by asking MySQL for the current time:

SELECT NOW();

In Go:

var currentTime time.Time

err :=
    db.QueryRow(
        "SELECT NOW()",
    ).Scan(
        &currentTime,
    )

if err != nil {
    log.Fatal(err)
}

fmt.Println(
    "MySQL time:",
    currentTime,
)

If this works, your Go application is successfully executing queries against MySQL.

Step 16: Insert Data into MySQL

MySQL parameter placeholders normally use:

Example:

INSERT INTO users (name, email)
VALUES (?, ?);

Go:

result, err :=
    db.Exec(
        `
        INSERT INTO users (
            name,
            email
        )
        VALUES (?, ?)
        `,
        "John",
        "john@example.com",
    )

if err != nil {
    log.Fatal(err)
}

Get the Inserted ID

For an auto-increment ID, use:

id, err :=
    result.LastInsertId()

Example:

if err != nil {
    log.Fatal(err)
}

fmt.Println(
    "Created user ID:",
    id,
)

Complete example:

result, err :=
    db.Exec(
        `
        INSERT INTO users (
            name,
            email
        )
        VALUES (?, ?)
        `,
        "John",
        "john@example.com",
    )

if err != nil {
    log.Fatal(err)
}

id, err :=
    result.LastInsertId()

if err != nil {
    log.Fatal(err)
}

fmt.Println(
    "Created user ID:",
    id,
)

MySQL vs PostgreSQL Placeholders

This is an important difference.

MySQL commonly uses:

Example:

WHERE email = ?

PostgreSQL commonly uses numbered placeholders:

$1

Example:

WHERE email = $1

If you switch databases, remember that query syntax can differ.

Step 17: Read One Record

Create a struct:

type User struct {
    ID    int64
    Name  string
    Email string
}

Fetch one user:

var user User

err :=
    db.QueryRow(
        `
        SELECT
            id,
            name,
            email
        FROM users
        WHERE id = ?
        `,
        1,
    ).Scan(
        &user.ID,
        &user.Name,
        &user.Email,
    )

Then:

if err != nil {
    log.Fatal(err)
}

fmt.Println(user)

Handling `sql.ErrNoRows`

If the requested record does not exist:

if err == sql.ErrNoRows {
    fmt.Println(
        "User not found",
    )

    return
}

A better pattern:

err :=
    db.QueryRow(
        `
        SELECT
            id,
            name,
            email
        FROM users
        WHERE id = ?
        `,
        userID,
    ).Scan(
        &user.ID,
        &user.Name,
        &user.Email,
    )

if err == sql.ErrNoRows {
    fmt.Println(
        "User not found",
    )

    return
}

if err != nil {
    log.Fatal(err)
}

Step 18: Read Multiple Records

Use:

db.Query()

Example:

rows, err :=
    db.Query(
        `
        SELECT
            id,
            name,
            email
        FROM users
        ORDER BY id
        `,
    )

if err != nil {
    log.Fatal(err)
}

defer rows.Close()

Iterate:

for rows.Next() {
    var user User

    err :=
        rows.Scan(
            &user.ID,
            &user.Name,
            &user.Email,
        )

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(user)
}

After iteration:

if err :=
    rows.Err();
    err != nil {

    log.Fatal(err)
}

Step 19: Update MySQL Data

Example:

result, err :=
    db.Exec(
        `
        UPDATE users
        SET
            name = ?,
            email = ?
        WHERE id = ?
        `,
        "John Smith",
        "johnsmith@example.com",
        1,
    )

if err != nil {
    log.Fatal(err)
}

Check affected rows:

affected, err :=
    result.RowsAffected()

if err != nil {
    log.Fatal(err)
}

fmt.Println(
    "Rows updated:",
    affected,
)

Step 20: Delete Data

Example:

result, err :=
    db.Exec(
        `
        DELETE FROM users
        WHERE id = ?
        `,
        1,
    )

if err != nil {
    log.Fatal(err)
}

Check:

affected, err :=
    result.RowsAffected()

if err != nil {
    log.Fatal(err)
}

fmt.Println(
    "Rows deleted:",
    affected,
)

Always Use Parameterized Queries

Never directly concatenate untrusted input into SQL.

Bad:

query :=
    "SELECT * FROM users WHERE email = '" +
        email +
        "'"

This can create SQL injection vulnerabilities.

Use:

db.QueryRow(
    `
    SELECT id, name, email
    FROM users
    WHERE email = ?
    `,
    email,
)

The SQL and values are passed separately.

Step 21: Configure MySQL Connection Pooling

An important concept is that:

*sql.DB

is not simply one connection.

It manages a connection pool.

Conceptually:

Go Application
      |
      v
    sql.DB
   /  |  \
Conn Conn Conn
   \  |  /
      v
    MySQL

Configure it:

db.SetMaxOpenConns(25)

db.SetMaxIdleConns(10)

db.SetConnMaxLifetime(
    30 * time.Minute,
)

db.SetConnMaxIdleTime(
    5 * time.Minute,
)

What Is `SetMaxOpenConns`?

db.SetMaxOpenConns(25)

sets the maximum number of open connections to MySQL.

Do not simply set an extremely high value.

The correct number depends on your database server and application architecture.

What Is `SetMaxIdleConns`?

db.SetMaxIdleConns(10)

controls how many unused connections can remain available for reuse.

What Is `SetConnMaxLifetime`?

db.SetConnMaxLifetime(
    30 * time.Minute,
)

limits how long a database connection may be reused.

What Is `SetConnMaxIdleTime`?

db.SetConnMaxIdleTime(
    5 * time.Minute,
)

limits how long an unused connection can remain idle.

Do Not Open MySQL for Every HTTP Request

Avoid this architecture:

HTTP Request
     |
     v
sql.Open()
     |
     v
Query
     |
     v
db.Close()

Instead:

Application Starts
       |
       v
Create sql.DB
       |
       v
Connection Pool
       |
       +---- Request 1
       +---- Request 2
       +---- Request 3
       |
       v
Application Shutdown
       |
       v
db.Close()

Create the database handle once and reuse it.

Step 22: Use Context with MySQL Queries

For HTTP applications, context-aware methods are useful.

Instead of:

db.Query()

you can use:

db.QueryContext()

Instead of:

db.Exec()

use:

db.ExecContext()

Instead of:

db.QueryRow()

use:

db.QueryRowContext()

Query with Context

Example:

ctx, cancel :=
    context.WithTimeout(
        context.Background(),
        3*time.Second,
    )

defer cancel()

var user User

err :=
    db.QueryRowContext(
        ctx,
        `
        SELECT
            id,
            name,
            email
        FROM users
        WHERE id = ?
        `,
        userID,
    ).Scan(
        &user.ID,
        &user.Name,
        &user.Email,
    )

This allows the query to respect cancellation and deadlines.

Using HTTP Request Context

Inside a Go HTTP handler:

ctx :=
    r.Context()

Then:

rows, err :=
    db.QueryContext(
        ctx,
        `
        SELECT
            id,
            name,
            email
        FROM users
        `,
    )

If the HTTP request is cancelled, the context can signal cancellation to the database operation.

Step 23: Create a Reusable Database Function

Instead of writing database setup directly in main(), create a reusable function.

func openDatabase(
    dsn string,
) (*sql.DB, error) {

    db, err :=
        sql.Open(
            "mysql",
            dsn,
        )

    if err != nil {
        return nil, err
    }

    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(10)

    db.SetConnMaxLifetime(
        30 * time.Minute,
    )

    db.SetConnMaxIdleTime(
        5 * time.Minute,
    )

    ctx, cancel :=
        context.WithTimeout(
            context.Background(),
            5*time.Second,
        )

    defer cancel()

    if err :=
        db.PingContext(ctx);
        err != nil {

        db.Close()

        return nil, err
    }

    return db, nil
}

Use:

db, err :=
    openDatabase(dsn)

if err != nil {
    log.Fatal(err)
}

defer db.Close()

Recommended Project Structure

For a larger backend:

go-mysql/
│
├── cmd/
│   └── api/
│       └── main.go
│
├── internal/
│   ├── database/
│   │   └── database.go
│   │
│   ├── models/
│   │   └── user.go
│   │
│   ├── repositories/
│   │   └── user_repository.go
│   │
│   ├── services/
│   └── handlers/
│
├── migrations/
│
├── go.mod
└── go.sum

Database Package Example

package database

import (
    "context"
    "database/sql"
    "time"

    _ "github.com/go-sql-driver/mysql"
)

func Open(
    dsn string,
) (*sql.DB, error) {

    db, err :=
        sql.Open(
            "mysql",
            dsn,
        )

    if err != nil {
        return nil, err
    }

    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(10)

    db.SetConnMaxLifetime(
        30 * time.Minute,
    )

    db.SetConnMaxIdleTime(
        5 * time.Minute,
    )

    ctx, cancel :=
        context.WithTimeout(
            context.Background(),
            5*time.Second,
        )

    defer cancel()

    if err :=
        db.PingContext(ctx);
        err != nil {

        db.Close()

        return nil, err
    }

    return db, nil
}

Connecting MySQL to a Go Web Server

A real application may look like:

func main() {
    dsn :=
        os.Getenv(
            "DATABASE_DSN",
        )

    if dsn == "" {
        log.Fatal(
            "DATABASE_DSN is required",
        )
    }

    db, err :=
        database.Open(dsn)

    if err != nil {
        log.Fatal(err)
    }

    defer db.Close()

    mux :=
        http.NewServeMux()

    // Register handlers here.

    log.Fatal(
        http.ListenAndServe(
            ":8080",
            mux,
        ),
    )
}

Pass `sql.DB` to a Handler

Example:

func usersHandler(
    db *sql.DB,
) http.HandlerFunc {

    return func(
        w http.ResponseWriter,
        r *http.Request,
    ) {

        rows, err :=
            db.QueryContext(
                r.Context(),
                `
                SELECT
                    id,
                    name,
                    email
                FROM users
                `,
            )

        if err != nil {
            http.Error(
                w,
                "Database error",
                http.StatusInternalServerError,
            )

            return
        }

        defer rows.Close()

        fmt.Fprintln(
            w,
            "MySQL query successful",
        )
    }
}

mux.HandleFunc(
    "/users",
    usersHandler(db),
)

Transactions with MySQL

MySQL supports transactions when using a transactional storage engine such as InnoDB.

Start:

tx, err :=
    db.Begin()

Execute:

_, err =
    tx.Exec(
        `
        UPDATE accounts
        SET balance = balance - ?
        WHERE id = ?
        `,
        amount,
        fromID,
    )

If everything succeeds:

tx.Commit()

If something fails:

tx.Rollback()

Transaction Example

func transfer(
    db *sql.DB,
    fromID int64,
    toID int64,
    amount float64,
) error {

    tx, err :=
        db.Begin()

    if err != nil {
        return err
    }

    defer tx.Rollback()

    _, err =
        tx.Exec(
            `
            UPDATE accounts
            SET balance =
                balance - ?
            WHERE id = ?
            `,
            amount,
            fromID,
        )

    if err != nil {
        return err
    }

    _, err =
        tx.Exec(
            `
            UPDATE accounts
            SET balance =
                balance + ?
            WHERE id = ?
            `,
            amount,
            toID,
        )

    if err != nil {
        return err
    }

    return tx.Commit()
}

Transactions are important when several related changes must succeed or fail together.

Handling MySQL NULL Values

SQL columns can contain:

NULL

Go provides nullable database types such as:

sql.NullString
sql.NullInt64
sql.NullBool
sql.NullTime
sql.NullFloat64

Example:

type User struct {
    ID    int64
    Name  string
    Phone sql.NullString
}

Check:

if user.Phone.Valid {
    fmt.Println(
        user.Phone.String,
    )
}

Useful MySQL DSN Parameters

Real applications may need additional DSN configuration.

For example:

go_user:password@tcp(127.0.0.1:3306)/go_app?parseTime=true

One particularly useful option is:

parseTime=true

It allows MySQL DATE and DATETIME values to be scanned into Go’s:

time.Time

Example DSN with `parseTime`

dsn :=
    "go_user:your_password@tcp(127.0.0.1:3306)/go_app?parseTime=true"

Then a model may contain:

type User struct {
    ID        int64
    Name      string
    Email     string
    CreatedAt time.Time
}

This is useful when reading timestamp columns.

Character Set Configuration

Applications dealing with Unicode text may configure MySQL appropriately.

A DSN can include parameters depending on your application’s requirements.

At the database level, modern applications commonly use utf8mb4 when full Unicode support is needed.

Make sure your:

Database
Tables
Columns
Connection configuration

use compatible character settings.

Common MySQL Connection Errors in Go

1. Connection Refused

You may see:

connect: connection refused

Possible causes include:

MySQL is not running
wrong host
wrong port
Docker networking issue
firewall restriction

Check whether MySQL is running.

The default port is:

2. Access Denied

You may see:

Access denied for user

Check:

Username
Password
Host permissions
MySQL grants
DSN

Try connecting manually:

mysql -u go_user -p -h 127.0.0.1

If this fails, fix the MySQL account or permissions before debugging Go code.

3. Unknown Database

Example:

Unknown database 'go_app'

Create it:

CREATE DATABASE go_app;

4. Unknown Driver

If you use:

sql.Open(
    "mysql",
    dsn,
)

but forget the driver import:

_ "github.com/go-sql-driver/mysql"

Go cannot use the MySQL driver.

Install:

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

and import it.

5. Wrong Port

MySQL normally uses:

But your installation or cloud provider may use another port.

Always verify your actual configuration.

6. Incorrect DSN

Make sure your DSN follows the expected format:

username:password@tcp(host:port)/database

Example:

go_user:password@tcp(127.0.0.1:3306)/go_app

7. Time Scanning Errors

If you want to scan MySQL date/time columns into:

time.Time

you may need:

parseTime=true

Example:

go_user:password@tcp(127.0.0.1:3306)/go_app?parseTime=true

Connecting Go to MySQL in Docker

If both Go and MySQL run in Docker Compose, do not normally use:

localhost

from one container to reach another container.

You might have:

services:
  app:
    build: .

  mysql:
    image: mysql

The Go container can typically reach the database using the service name:

mysql

A DSN might therefore use:

go_user:password@tcp(mysql:3306)/go_app

The exact configuration depends on your Docker network and Compose setup.

Connecting to Cloud MySQL

Go can also connect to hosted MySQL databases.

The provider normally gives you:

Host
Port
Username
Password
Database name
TLS/SSL requirements

Use these values to configure your application securely.

Do not assume a cloud database can be accessed using:

localhost

The host will normally be provided by your database service.

Production Security Best Practices

For production applications:

do not use the root account
do not hardcode passwords
use environment variables or secret management
follow least-privilege database permissions
use TLS when required
use parameterized queries
limit database network access
configure connection pooling
use query timeouts
rotate compromised credentials
monitor connection failures
keep MySQL and the Go driver updated

MySQL vs PostgreSQL Connection in Go

The basic database/sql workflow is similar.

MySQL:

sql.Open(
    "mysql",
    mysqlDSN,
)

PostgreSQL with pgx:

sql.Open(
    "pgx",
    postgresURL,
)

MySQL commonly uses:

for query placeholders.

PostgreSQL commonly uses:

$1
$2

Despite database-specific differences, the core Go concepts remain similar:

sql.Open
Ping
Exec
Query
QueryRow
Scan
Transactions
Context
Connection pooling

Complete Practical MySQL Example

The following example connects to MySQL, verifies the connection, inserts a user, and retrieves users.

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "os"
    "time"

    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    ID        int64
    Name      string
    Email     string
    CreatedAt time.Time
}

func main() {
    dsn :=
        os.Getenv(
            "DATABASE_DSN",
        )

    if dsn == "" {
        log.Fatal(
            "DATABASE_DSN is required",
        )
    }

    db, err :=
        sql.Open(
            "mysql",
            dsn,
        )

    if err != nil {
        log.Fatal(
            "Failed to open MySQL:",
            err,
        )
    }

    defer db.Close()

    db.SetMaxOpenConns(20)
    db.SetMaxIdleConns(10)

    db.SetConnMaxLifetime(
        30 * time.Minute,
    )

    ctx, cancel :=
        context.WithTimeout(
            context.Background(),
            5*time.Second,
        )

    defer cancel()

    if err :=
        db.PingContext(ctx);
        err != nil {

        log.Fatal(
            "Failed to connect to MySQL:",
            err,
        )
    }

    fmt.Println(
        "Connected to MySQL",
    )

    result, err :=
        db.ExecContext(
            ctx,
            `
            INSERT INTO users (
                name,
                email
            )
            VALUES (?, ?)
            `,
            "John",
            "john@example.com",
        )

    if err != nil {
        log.Fatal(
            "Insert failed:",
            err,
        )
    }

    id, err :=
        result.LastInsertId()

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(
        "Created user ID:",
        id,
    )

    rows, err :=
        db.QueryContext(
            ctx,
            `
            SELECT
                id,
                name,
                email,
                created_at
            FROM users
            ORDER BY id
            `,
        )

    if err != nil {
        log.Fatal(
            "Query failed:",
            err,
        )
    }

    defer rows.Close()

    for rows.Next() {
        var user User

        err :=
            rows.Scan(
                &user.ID,
                &user.Name,
                &user.Email,
                &user.CreatedAt,
            )

        if err != nil {
            log.Fatal(err)
        }

        fmt.Printf(
            "%d | %s | %s | %v\n",
            user.ID,
            user.Name,
            user.Email,
            user.CreatedAt,
        )
    }

    if err :=
        rows.Err();
        err != nil {

        log.Fatal(err)
    }
}

For this example, set a DSN containing parseTime=true:

export DATABASE_DSN="go_user:your_password@tcp(127.0.0.1:3306)/go_app?parseTime=true"

Run:

go run main.go

What Should You Learn Next?

Once the MySQL connection is working, continue with:

INSERT queries
SELECT queries
UPDATE queries
DELETE queries
Prepared statements
Transactions
JOINs
Indexes
Pagination
Context and timeouts
Database migrations
Repository pattern
REST API integration
Authentication
Testing
Docker
Deployment

Frequently Asked Questions

How do I connect MySQL with Go?

Use Go’s database/sql package together with a MySQL driver.

Example:

db, err :=
    sql.Open(
        "mysql",
        dsn,
    )

Then verify it:

db.Ping()

Which MySQL driver can I use with Go?

A commonly used driver is:

github.com/go-sql-driver/mysql

Install it with:

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

What is the default MySQL port?

The default MySQL TCP port is:

What is a MySQL DSN?

DSN stands for Data Source Name.

A common MySQL DSN format is:

username:password@tcp(host:port)/database

Does `sql.Open()` connect to MySQL immediately?

Not necessarily.

It creates a sql.DB database handle and connection pool.

Use:

db.Ping()

or:

db.PingContext()

to verify connectivity.

What is `sql.DB`?

sql.DB is a concurrency-safe database handle that manages a pool of database connections.

It should normally be long-lived and reused across your application.

Should I call `sql.Open()` for every HTTP request?

No.

Open the database when the application starts, reuse the sql.DB pool, and close it during application shutdown.

How do I prevent SQL injection with MySQL and Go?

Use parameterized queries.

Example:

db.QueryRow(
    `
    SELECT id, name
    FROM users
    WHERE email = ?
    `,
    email,
)

Never concatenate untrusted user input directly into SQL.

Why do I need `parseTime=true`?

It is useful when you want MySQL date and time values to be scanned into Go’s time.Time.

Example DSN:

go_user:password@tcp(localhost:3306)/go_app?parseTime=true

Should I use the MySQL root account in my Go application?

Generally, no.

Create a dedicated application user with only the permissions the application needs.

Can Go connect to a cloud MySQL database?

Yes.

Use the connection details provided by your hosting service, including its host, port, database, credentials, and required TLS configuration.

Is MySQL good for Go REST APIs?

Yes.

MySQL can work well with Go for REST APIs, web applications, e-commerce systems, SaaS products, dashboards, and microservices.

Conclusion

Connecting MySQL with Go requires only a few core components:

MySQL Server
      ↓
MySQL Database
      ↓
Go database/sql
      ↓
MySQL Driver

The essential connection code is:

db, err :=
    sql.Open(
        "mysql",
        dsn,
    )

Then verify connectivity:

err =
    db.Ping()

For a real production application, improve this basic setup with:

Environment variables
Dedicated database users
Context and timeouts
Connection pooling
Parameterized queries
TLS
Secure credentials
Error handling
Monitoring
Repository architecture

Once your Go application is successfully connected to MySQL, you can move on to CRUD operations, transactions, joins, migrations, authentication, and complete database-backed REST APIs.

Understanding this connection process also gives you a strong foundation for working with Go’s database/sql package and other relational databases.

How to Connect MySQL with Go: Complete Guide

What Do You Need to Connect MySQL with Go?

Why Use MySQL with Go?

Step 1: Install MySQL

Step 2: Start MySQL

Step 3: Log In to MySQL

Step 4: Create a MySQL Database

Step 5: Create a Dedicated MySQL User

Step 6: Create a Go Project

Step 7: Install the MySQL Driver

Step 8: Import database/sql and the MySQL Driver

Step 9: Understand the MySQL DSN

Step 10: Connect MySQL with sql.Open

Important: sql.Open() Does Not Guarantee a Connection

Step 11: Verify the MySQL Connection

Complete MySQL Connection Example

Step 12: Use PingContext

Complete Connection with Timeout

Step 13: Store MySQL Credentials in Environment Variables

Set the Environment Variable

Using a .env File

Step 14: Create a MySQL Table

Step 15: Test MySQL with a Simple Query

Step 16: Insert Data into MySQL

Get the Inserted ID

MySQL vs PostgreSQL Placeholders

Step 17: Read One Record

Handling sql.ErrNoRows

Step 18: Read Multiple Records

Step 19: Update MySQL Data

Step 20: Delete Data

Always Use Parameterized Queries

Step 21: Configure MySQL Connection Pooling

What Is SetMaxOpenConns?

What Is SetMaxIdleConns?

What Is SetConnMaxLifetime?

What Is SetConnMaxIdleTime?

Do Not Open MySQL for Every HTTP Request

Step 22: Use Context with MySQL Queries

Query with Context

Using HTTP Request Context

Step 23: Create a Reusable Database Function

Recommended Project Structure

Database Package Example

Connecting MySQL to a Go Web Server

Pass sql.DB to a Handler

Transactions with MySQL

Transaction Example

Handling MySQL NULL Values

Useful MySQL DSN Parameters

Example DSN with parseTime

Character Set Configuration

Common MySQL Connection Errors in Go

1. Connection Refused

2. Access Denied

3. Unknown Database

4. Unknown Driver

5. Wrong Port

6. Incorrect DSN

7. Time Scanning Errors

Connecting Go to MySQL in Docker

Connecting to Cloud MySQL

Production Security Best Practices

MySQL vs PostgreSQL Connection in Go

Complete Practical MySQL Example

What Should You Learn Next?

Frequently Asked Questions

How do I connect MySQL with Go?

Which MySQL driver can I use with Go?

What is the default MySQL port?

What is a MySQL DSN?

Does sql.Open() connect to MySQL immediately?

What is sql.DB?

Should I call sql.Open() for every HTTP request?

How do I prevent SQL injection with MySQL and Go?

Why do I need parseTime=true?

Should I use the MySQL root account in my Go application?

Can Go connect to a cloud MySQL database?

Is MySQL good for Go REST APIs?

Conclusion

Step 8: Import `database/sql` and the MySQL Driver

Step 10: Connect MySQL with `sql.Open`

Important: `sql.Open()` Does Not Guarantee a Connection

Step 12: Use `PingContext`

Using a `.env` File

Handling `sql.ErrNoRows`

What Is `SetMaxOpenConns`?

What Is `SetMaxIdleConns`?

What Is `SetConnMaxLifetime`?

What Is `SetConnMaxIdleTime`?

Pass `sql.DB` to a Handler

Example DSN with `parseTime`

Does `sql.Open()` connect to MySQL immediately?

What is `sql.DB`?

Should I call `sql.Open()` for every HTTP request?

Why do I need `parseTime=true`?