How to create high-performance MySQL data granular control using Go language

MySQL is a very popular relational database management system, and the Go language is a fast and efficient programming language that has excellent performance in many scenarios. This article will introduce how to use Go language to create high-performance MySQL data granular control, providing more efficient data reading and writing operations for your website or business system.

1. Use Go language to connect to MySQL

First, you need to use Go language to connect to the MySQL database. There are two main MySQL drivers available in Go language: Go-MySQL-Driver and MySQL Driver. For most cases, Go-MySQL-Driver is preferred because it has better performance and stability, while MySQL Driver does not handle Unicode characters as well as Go-MySQL-Driver. Depending on your needs, you can install Go-MySQL-Driver using the following command:

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

Next, you can use the following code to connect to the MySQL database:

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, err := sql.Open("mysql", "username:password@tcp(127.0.0.1:3306)/dbname")
    if err != nil {
        panic(err.Error())
    }
    defer db.Close()
}

Where, "username" and "password" are the username and password you chose when creating the user in MySQL, and "dbname" is the name of the database you will be connecting to.

2. Use Go language to execute MySQL query

After connecting to the database, you can use Go language to execute MySQL query and obtain the returned results. The following are some basic MySQL query operation examples:

1. Insert a record:

func createRecord(db *sql.DB, name string, age int) {
    stmt, err := db.Prepare("INSERT INTO users(name, age) VALUES(?, ?)")
    if err != nil {
        panic(err.Error())
    }
    _, err = stmt.Exec(name, age)
    if err != nil {
        panic(err.Error())
    }
}

In this example, we use the Prepare and Exec functions to execute the insert command.

2. Update a record:

func updateRecord(db *sql.DB, name string, age int, id int64) {
    stmt, err := db.Prepare("UPDATE users SET name=?, age=? WHERE id=?")
    if err != nil {
        panic(err.Error())
    }
    _, err = stmt.Exec(name, age, id)
    if err != nil {
        panic(err.Error())
    }
}

In this example, we use the UPDATE statement to update a record, and use the Prepare and Exec functions to execute the command.

3. Get a single record:

func getRecord(db *sql.DB, id int64) (string, int, error) {
    var name string
    var age int
    err := db.QueryRow("SELECT name, age FROM users WHERE id=?", id).Scan(&name, &age)
    if err != nil {
        return "", 0, err
    }
    return name, age, nil
}

In this example, we use the QueryRow and Scan functions to obtain the data of a record.

4. Get multiple records:

func getRecords(db *sql.DB) []User {
    var users []User
    rows, err := db.Query("SELECT name, age FROM users")
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()
 
    for rows.Next() {
        var user User
        err := rows.Scan(&user.Name, &user.Age)
        if err != nil {
            panic(err.Error())
        }
        users = append(users, user)
    }
    return users
}

In this example, we use the Query function and the Scan function to get multiple pieces of data and save them in a slice return.

3. Use Go language for data granularity control

In actual business environments, we sometimes need to perform data granularity control to achieve better performance and data security. The following are some examples of data granularity control:

1. Query for a given time range:

func queryUsersByTime(db *sql.DB, startTime, endTime string) []User {
    var users []User
    rows, err := db.Query("SELECT name, age FROM users WHERE created_at BETWEEN ? AND ?", startTime, endTime)
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()
 
    for rows.Next() {
        var user User
        err := rows.Scan(&user.Name, &user.Age)
        if err != nil {
            panic(err.Error())
        }
        users = append(users, user)
    }
    return users
}

In this example, we use the BETWEEN operator to specify the time range, to query for users created within a specific time range.

2. Query by group:

func queryUsersByGroup(db *sql.DB, age int) (int, error) {
    var count int
    err := db.QueryRow("SELECT COUNT(*) FROM users WHERE age=?", age).Scan(&count)
    if err != nil {
        return 0, err
    }
    return count, nil
}

In this example, we use the COUNT function and WHERE clause to count the number of users of a specified age.

3. Use index query:

func queryUsersByIndex(db *sql.DB, name string) []User {
    var users []User
    rows, err := db.Query("SELECT name, age FROM users WHERE name=?", name)
    if err != nil {
        panic(err.Error())
    }
    defer rows.Close()
 
    for rows.Next() {
        var user User
        err := rows.Scan(&user.Name, &user.Age)
        if err != nil {
            panic(err.Error())
        }
        users = append(users, user)
    }
    return users
}

In this example, we use the index (name) to query all users with a given name.

Summary:

This article introduces how to use Go language to create high-performance MySQL data granular control. With these simple queries and controls, you can write more complex MySQL operations based on your specific needs and maximize the efficiency of the Go language. With granular data control, your website or business system can not only process data requests faster, but also store and manipulate sensitive data more securely.

The above is the detailed content of How to create high-performance MySQL data granular control using Go language. For more information, please follow other related articles on the PHP Chinese website!