Using MySQL in Go language to achieve reliable data transmission

With the rapid development of big data and cloud computing technology, the amount of data is increasing, and data processing and transmission are becoming more and more important. Reliability is very important during data transmission because if any problem occurs during data transmission, the entire system may suffer. Therefore, how to achieve reliable data transmission has become a very important issue. In the Go language, the reliable transmission of data can be well achieved by using the MySQL database.

MySQL is a popular relational database management system developed by Oracle Corporation. MySQL has high availability and reliability, and can support highly concurrent data reading and writing operations. Therefore, using MySQL for data transfer is very reliable and fast.

In Go language, the steps to use MySQL to implement data transmission are as follows:

1. Connect to MySQL database

In Go language, use Go-MySQL -Driver package can easily connect to MySQL database. The package can be installed through the go get command. The installation command is as follows:

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

After importing the package in the code, you can use the following code to connect to the MySQL database:

db, err := sql.Open("mysql", "root:password@tcp(127.0.0.1:3306)/dbname")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

Among them, root is Database user name, password is the database password, 127.0.0.1 is the database address, 3306 is the MySQL port number, and dbname is the database name.

2. Creation of database table

In the MySQL database, you need to first create a table to store data. The table structure can be set according to actual business needs, for example:

CREATE TABLE IF NOT EXISTS `data` (
    `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
    `time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
    `data` text NOT NULL,
    PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

The table contains three fields: id is the self-increasing id, time is the timestamp, and data is the stored data.

3. Writing and reading of data

In the Go language, use the Exec() method of the sql.DB object to write data to the MySQL database.

stmt, err := db.Prepare("INSERT INTO data(time, data) VALUES(?, ?)")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()
res, err := stmt.Exec(time.Now(), "data")
if err != nil {
    log.Fatal(err)
}
id, err := res.LastInsertId()
if err != nil {
    log.Fatal(err)
}

In the above code, a SQL statement is first constructed using the Prepare() method, and then the Exec() method is used to execute the SQL statement and write the data into the database. After successful execution, the ID of the inserted data can be obtained.

When reading data, you can use the Query() method of the sql.DB object to perform query operations.

rows, err := db.Query("SELECT * FROM data")
if err != nil {
    log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
    var id int
    var time time.Time
    var data string
    if err := rows.Scan(&id, &time, &data); err != nil {
        log.Fatal(err)
    }
    fmt.Println(id, time, data)
}
if err := rows.Err(); err != nil {
    log.Fatal(err)
}

In the above code, the Query() method is first used to perform the query operation and obtain a result set. Then use the Next() method to iterate through each row of data in the result set, and use the Scan() method to store each row of data into a variable.

4. Modification and deletion of data

In Go language, use the Exec() method of the sql.DB object to modify and delete data.

The code to modify the data is as follows:

stmt, err := db.Prepare("UPDATE data SET data=? WHERE id=?")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()
res, err := stmt.Exec("new data", id)
if err != nil {
    log.Fatal(err)
}
rowsAffected, err := res.RowsAffected()
if err != nil {
    log.Fatal(err)
}

The code to delete the data is as follows:

stmt, err := db.Prepare("DELETE FROM data WHERE id=?")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()
res, err := stmt.Exec(id)
if err != nil {
    log.Fatal(err)
}
rowsAffected, err := res.RowsAffected()
if err != nil {
    log.Fatal(err)
}

In the above code, first use the Exec() method to perform the modification or deletion operation, and then use RowsAffected() method gets the number of affected rows.

Summary

Using MySQL in the Go language to achieve reliable data transmission requires first connecting to the MySQL database, then creating a table structure, and finally using the Exec() method to add, delete, modify, and query data. Using the MySQL database can ensure the reliability of data during data transmission and improve the stability and reliability of the system.

The above is the detailed content of Using MySQL in Go language to achieve reliable data transmission. For more information, please follow other related articles on the PHP Chinese website!