SQL fait référence au « langage de requête structuré », qui est un langage permettant d'exploiter des bases de données, notamment la création de bases de données, la suppression de bases de données, l'interrogation d'enregistrements, la modification d'enregistrements, l'ajout de champs, etc. SQL est le langage standard pour les bases de données relationnelles. Tous les systèmes de gestion de bases de données relationnelles (SGBDR), tels que MySQL, Oracle, SQL Server, MS Access, Sybase, Informix, Postgres, etc., utilisent SQL comme langage de traitement standard.
L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.
Qu'est-ce que SQL
SQL est un langage permettant d'exploiter des bases de données, notamment la création de bases de données, la suppression de bases de données, l'interrogation d'enregistrements, la modification d'enregistrements, l'ajout de champs, etc. Bien que SQL soit un langage standardisé par ANSI, il existe de nombreuses implémentations différentes.
SQL est l'abréviation de Structured Query Language, qui se traduit en chinois par « Structured Query Language ». SQL est un langage informatique utilisé pour stocker, récupérer et modifier des données stockées dans des bases de données relationnelles.
SQL est le langage standard pour les bases de données relationnelles. Tous les systèmes de gestion de bases de données relationnelles (SGBDR), tels que MySQL, Oracle, SQL Server, MS Access, Sybase, Informix, Postgres, etc., utilisent SQL comme langage de traitement standard.
Objectifs de SQL
SQL est populaire en raison de ses utilisations suivantes :
Permet aux utilisateurs d'accéder aux données dans les systèmes de bases de données relationnelles
Permet aux utilisateurs de décrire les données ; données dans la base de données et traiter les données ;
Permet aux modules SQL, aux bibliothèques ou aux préprocesseurs d'être intégrés dans d'autres langages de programmation ;
Permet aux utilisateurs de créer et de supprimer des bases de données, des tables et des éléments de données (Enregistrement) ;
La bibliothèque standard du langage Go fournit une bibliothèque SQL pour les opérations de base de données, et vous pouvez utiliser le langage SQL pour faire fonctionner la base de données.
1.1 Connect
go get -u github.com/go-sql-driver/mysql
func Open(driverName, dataSourceName string) (*DB, error)
dataSourceName Source de données spécifiée, comprend généralement au moins le nom du fichier de base de données et d'autres informations nécessaires à la connexion.
import (
"database/sql"
_ "github.com/go-sql-driver/mysql"
)
func main() {
// DSN:Data Source Name
dsn := "user:password@tcp(127.0.0.1:3306)/dbname"
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
defer db.Close() // 注意这行代码要写在上面err判断的下面
}appeler la méthode Ping
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
//需要注意 这里需要引用自己的mysql文件
var db *sql.DB
func initDB()(err error) {
//账号 密码 端口号(tcp)127.0.0.1:3306 表名 字符集 校验时间
dsn := "root:123456@tcp(127.0.0.1:3306)/gomysql?charset=utf8mb4&parseTime=true"
//加载驱动
//这里需要是=而不是:=因为我们是给全局变量(db)赋值
db,err = sql.Open("mysql",dsn)
if err!=nil {
return err
}
//尝试和数据库建立连接(校验dsn正确)
//然后用了ping命令
err=db.Ping()
if err!=nil {
return err
}
return nil
}
func main() {
err := initDB()
if err!=nil {
fmt.Printf("connect failed,err:%v\n",err)
return
}
}SetMaxOpenConnsDéfinir le maximum nombre de connexions à la base de données . Si n est supérieur à 0 et inférieur au nombre maximum de connexions inactives, le . Si n<=0, le nombre maximum de connexions ouvertes ne sera pas limité, SetMaxOpenConns设置与数据库建立连接的最大数目。 如果n大于0且小于最大闲置连接数，会将最大闲置连接数减小到匹配最大开启连接数的限制。 如果n<=0，不会限制最大开启连接数，默认为0（无限制）
func (db *DB) SetMaxIdleConns(n int)
连接池中的最大闲置连接数
如果n大于最大开启连接数，则新的最大闲置连接数会减小到匹配最大开启连接数的限制。 如果n<=0，不会保留闲置连接。
我们先在MySQL中创建一个名为sql_test的数据库
CREATE DATABASE sql_test;
进入该数据库:
use sql_test;
执行以下命令创建一张用于测试的数据表：
CREATE TABLE `user` (
`id` BIGINT(20) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(20) DEFAULT '',
`age` INT(11) DEFAULT '0',
PRIMARY KEY(`id`)
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;单行查询db.QueryRow()执行一次查询，并期望返回最多一行结果（即Row）。QueryRow总是返回非nil的值，直到返回值的Scan方法被调用时，才会返回被延迟的错误。（如：未找到结果）
func (db *DB) QueryRow(query string, args ...interface{}) *Rowfunc queryRowDemo() {
sqlStr := "select id, name, age from user where id=?"
var u user
// 非常重要：确保QueryRow之后调用Scan方法，否则持有的数据库链接不会被释放
err := db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}func (db *DB) Query(query string, args ...interface{}) (*Rows, error)// 查询多条数据示例
func queryMultiRowDemo() {
sqlStr := "select id, name, age from user where id > ?"
rows, err := db.Query(sqlStr, 0)
if err != nil {
fmt.Printf("query failed, err:%v\n", err)
return
}
// 非常重要：关闭rows释放持有的数据库链接
defer rows.Close()
// 循环读取结果集中的数据
for rows.Next() {
var u user
err := rows.Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
}插入、更新和删除操作都使用Execla valeur par défaut est 0 (illimité)
func (db *DB) Exec(query string, args ...interface{}) (Result, error)Si n
est supérieur au nombre maximum de connexions ouvertes 🎜, alors le nouveau nombre maximum de connexions inactives sera réduit pour correspondre à la limite 🎜 du nombre maximum de connexions ouvertes 🎜. Si 🎜n<=0, les connexions inactives 🎜 ne seront pas conservées. 🎜🎜🎜🎜1.2CRUD🎜🎜🎜🎜1.2.1 Construire la base de données et la table🎜🎜🎜Nous créons d'abord une base de données nomméesql_test dans MySQL🎜// 插入数据
func insertRowDemo() {
sqlStr := "insert into user(name, age) values (?,?)"
ret, err := db.Exec(sqlStr, "王五", 38)
if err != nil {
fmt.Printf("insert failed, err:%v\n", err)
return
}
theID, err := ret.LastInsertId() // 新插入数据的id
if err != nil {
fmt.Printf("get lastinsert ID failed, err:%v\n", err)
return
}
fmt.Printf("insert success, the id is %d.\n", theID)
}// 更新数据
func updateRowDemo() {
sqlStr := "update user set age=? where id = ?"
ret, err := db.Exec(sqlStr, 39, 3)
if err != nil {
fmt.Printf("update failed, err:%v\n", err)
return
}
n, err := ret.RowsAffected() // 操作影响的行数
if err != nil {
fmt.Printf("get RowsAffected failed, err:%v\n", err)
return
}
fmt.Printf("update success, affected rows:%d\n", n)
}// 删除数据
func deleteRowDemo() {
sqlStr := "delete from user where id = ?"
ret, err := db.Exec(sqlStr, 3)
if err != nil {
fmt.Printf("delete failed, err:%v\n", err)
return
}
n, err := ret.RowsAffected() // 操作影响的行数
if err != nil {
fmt.Printf("get RowsAffected failed, err:%v\n", err)
return
}
fmt.Printf("delete success, affected rows:%d\n", n)
}db.QueryRow() exécute une requête et s'attend à renvoyer au plus une ligne de résultats (c'est-à-dire Row). QueryRow renvoie toujours une valeur non nulle et ne renvoie pas d'erreur retardée jusqu'à ce que la méthode Scan qui renvoie la valeur soit appelée. (Par exemple : aucun résultat trouvé)🎜package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
// 定义一个全局对象db
var db *sql.DB
// 定义一个初始化数据库的函数
func initDB() (err error) {
// DSN:Data Source Name
dsn := "root:123456@tcp(127.0.0.1:3306)/sql_test?charset=utf8&parseTime=True"
// 不会校验账号密码是否正确
// 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
db, err = sql.Open("mysql", dsn)
if err != nil {
return err
}
// 尝试与数据库建立连接（校验dsn是否正确）
err = db.Ping()
if err != nil {
return err
}
return nil
}
type user struct {
id int
age int
name string
}
func queryRowDemo() {
sqlStr := "select id, name, age from user where id=?"
var u user
// 非常重要：确保QueryRow之后调用Scan方法，否则持有的数据库链接不会被释放
err := db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
// 查询多条数据示例
func queryMultiRowDemo() {
sqlStr := "select id, name, age from user where id > ?"
rows, err := db.Query(sqlStr, 0)
if err != nil {
fmt.Printf("query failed, err:%v\n", err)
return
}
// 非常重要：关闭rows释放持有的数据库链接
defer rows.Close()
// 循环读取结果集中的数据
for rows.Next() {
var u user
err := rows.Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
}
func insertRowDemo() {
sqlStr := "insert into user(name,age) value (?,?)"
//
ret,err := db.Exec(sqlStr,"王五",40)
if err!=nil {
fmt.Printf("inserf failed,err:%v\n",err)
return
}
//插入成功之后需要返回这个id
theID,err:=ret.LastInsertId()
if err != nil{
fmt.Printf("get the last insertid failed,err:%v\n",theID)
return
}
fmt.Printf("insert success,theID is:%v\n",theID)
}
func updateRowDemo() {
sqlStr := "update user set name =? where id = ?"
//执行含有sqlStr参数的语句
ret,err:=db.Exec(sqlStr,"赵四",4)
if err!=nil {
fmt.Printf("update failed,err:%v\n",err)
return
}
AnoID,err:=ret.RowsAffected()
if err!=nil {
fmt.Printf("updateRowAffected failed,err:%v\n",err)
return
}
fmt.Printf("update success AnoID:%v\n",AnoID)
}
// 删除数据
func deleteRowDemo() {
sqlStr := "delete from user where id = ?"
ret, err := db.Exec(sqlStr, 5)
if err != nil {
fmt.Printf("delete failed, err:%v\n", err)
return
}
n, err := ret.RowsAffected() // 操作影响的行数
if err != nil {
fmt.Printf("get RowsAffected failed, err:%v\n", err)
return
}
fmt.Printf("delete success, affected rows:%d\n", n)
}
func main() {
err := initDB() // 调用输出化数据库的函数
if err != nil {
fmt.Printf("init db failed,err:%v\n", err)
return
}
//queryRowDemo()
//insertRowDemo()
//updateRowDemo()
deleteRowDemo()
queryMultiRowDemo()
}func (db *DB) Prepare(query string) (*Stmt, error)
// 预处理查询示例
func prepareQueryDemo() {
sqlStr := "select id, name, age from user where id > ?"
stmt, err := db.Prepare(sqlStr)
if err != nil {
fmt.Printf("prepare failed, err:%v\n", err)
return
}
defer stmt.Close()
rows, err := stmt.Query(0)
if err != nil {
fmt.Printf("query failed, err:%v\n", err)
return
}
defer rows.Close()
// 循环读取结果集中的数据
for rows.Next() {
var u user
err := rows.Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
}// 预处理插入示例
func prepareInsertDemo() {
sqlStr := "insert into user(name, age) values (?,?)"
stmt, err := db.Prepare(sqlStr)
if err != nil {
fmt.Printf("prepare failed, err:%v\n", err)
return
}
defer stmt.Close()
_, err = stmt.Exec("小王子", 18)
if err != nil {
fmt.Printf("insert failed, err:%v\n", err)
return
}
_, err = stmt.Exec("沙河娜扎", 18)
if err != nil {
fmt.Printf("insert failed, err:%v\n", err)
return
}
fmt.Println("insert success.")
}Exec. 🎜// sql注入示例
func sqlInjectDemo(name string) {
sqlStr := fmt.Sprintf("select id, name, age from user where name='%s'", name)
fmt.Printf("SQL:%s\n", sqlStr)
var u user
err := db.QueryRow(sqlStr).Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("exec failed, err:%v\n", err)
return
}
fmt.Printf("user:%#v\n", u)
}sqlInjectDemo("xxx' or 1=1#")
sqlInjectDemo("xxx' union select * from user #")
sqlInjectDemo("xxx' and (select count(*) from user) <10 #")// 更新数据
func updateRowDemo() {
sqlStr := "update user set age=? where id = ?"
ret, err := db.Exec(sqlStr, 39, 3)
if err != nil {
fmt.Printf("update failed, err:%v\n", err)
return
}
n, err := ret.RowsAffected() // 操作影响的行数
if err != nil {
fmt.Printf("get RowsAffected failed, err:%v\n", err)
return
}
fmt.Printf("update success, affected rows:%d\n", n)
}具体删除数据的示例代码如下：
// 删除数据
func deleteRowDemo() {
sqlStr := "delete from user where id = ?"
ret, err := db.Exec(sqlStr, 3)
if err != nil {
fmt.Printf("delete failed, err:%v\n", err)
return
}
n, err := ret.RowsAffected() // 操作影响的行数
if err != nil {
fmt.Printf("get RowsAffected failed, err:%v\n", err)
return
}
fmt.Printf("delete success, affected rows:%d\n", n)
}package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
// 定义一个全局对象db
var db *sql.DB
// 定义一个初始化数据库的函数
func initDB() (err error) {
// DSN:Data Source Name
dsn := "root:123456@tcp(127.0.0.1:3306)/sql_test?charset=utf8&parseTime=True"
// 不会校验账号密码是否正确
// 注意！！！这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
db, err = sql.Open("mysql", dsn)
if err != nil {
return err
}
// 尝试与数据库建立连接（校验dsn是否正确）
err = db.Ping()
if err != nil {
return err
}
return nil
}
type user struct {
id int
age int
name string
}
func queryRowDemo() {
sqlStr := "select id, name, age from user where id=?"
var u user
// 非常重要：确保QueryRow之后调用Scan方法，否则持有的数据库链接不会被释放
err := db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
// 查询多条数据示例
func queryMultiRowDemo() {
sqlStr := "select id, name, age from user where id > ?"
rows, err := db.Query(sqlStr, 0)
if err != nil {
fmt.Printf("query failed, err:%v\n", err)
return
}
// 非常重要：关闭rows释放持有的数据库链接
defer rows.Close()
// 循环读取结果集中的数据
for rows.Next() {
var u user
err := rows.Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
}
func insertRowDemo() {
sqlStr := "insert into user(name,age) value (?,?)"
//
ret,err := db.Exec(sqlStr,"王五",40)
if err!=nil {
fmt.Printf("inserf failed,err:%v\n",err)
return
}
//插入成功之后需要返回这个id
theID,err:=ret.LastInsertId()
if err != nil{
fmt.Printf("get the last insertid failed,err:%v\n",theID)
return
}
fmt.Printf("insert success,theID is:%v\n",theID)
}
func updateRowDemo() {
sqlStr := "update user set name =? where id = ?"
//执行含有sqlStr参数的语句
ret,err:=db.Exec(sqlStr,"赵四",4)
if err!=nil {
fmt.Printf("update failed,err:%v\n",err)
return
}
AnoID,err:=ret.RowsAffected()
if err!=nil {
fmt.Printf("updateRowAffected failed,err:%v\n",err)
return
}
fmt.Printf("update success AnoID:%v\n",AnoID)
}
// 删除数据
func deleteRowDemo() {
sqlStr := "delete from user where id = ?"
ret, err := db.Exec(sqlStr, 5)
if err != nil {
fmt.Printf("delete failed, err:%v\n", err)
return
}
n, err := ret.RowsAffected() // 操作影响的行数
if err != nil {
fmt.Printf("get RowsAffected failed, err:%v\n", err)
return
}
fmt.Printf("delete success, affected rows:%d\n", n)
}
func main() {
err := initDB() // 调用输出化数据库的函数
if err != nil {
fmt.Printf("init db failed,err:%v\n", err)
return
}
//queryRowDemo()
//insertRowDemo()
//updateRowDemo()
deleteRowDemo()
queryMultiRowDemo()
}普通SQL语句执行过程：
客户端对SQL语句进行占位符替换得到完整的SQL语句。
客户端发送完整SQL语句到MySQL服务端
MySQL服务端执行完整的SQL语句并将结果返回给客户端。
预处理执行过程：
把SQL语句分成两部分，命令部分与数据部分。
先把命令部分发送给MySQL服务端，MySQL服务端进行SQL预处理。
然后把数据部分发送给MySQL服务端，MySQL服务端对SQL语句进行占位符替换。
MySQL服务端执行完整的SQL语句并将结果返回给客户端
优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。
避免SQL注入问题。
func (db *DB) Prepare(query string) (*Stmt, error)
查询操作的预处理示例代码如下：
// 预处理查询示例
func prepareQueryDemo() {
sqlStr := "select id, name, age from user where id > ?"
stmt, err := db.Prepare(sqlStr)
if err != nil {
fmt.Printf("prepare failed, err:%v\n", err)
return
}
defer stmt.Close()
rows, err := stmt.Query(0)
if err != nil {
fmt.Printf("query failed, err:%v\n", err)
return
}
defer rows.Close()
// 循环读取结果集中的数据
for rows.Next() {
var u user
err := rows.Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("scan failed, err:%v\n", err)
return
}
fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}
}插入、更新和删除操作的预处理十分类似，这里以插入操作的预处理为例：
// 预处理插入示例
func prepareInsertDemo() {
sqlStr := "insert into user(name, age) values (?,?)"
stmt, err := db.Prepare(sqlStr)
if err != nil {
fmt.Printf("prepare failed, err:%v\n", err)
return
}
defer stmt.Close()
_, err = stmt.Exec("小王子", 18)
if err != nil {
fmt.Printf("insert failed, err:%v\n", err)
return
}
_, err = stmt.Exec("沙河娜扎", 18)
if err != nil {
fmt.Printf("insert failed, err:%v\n", err)
return
}
fmt.Println("insert success.")
}我们任何时候都不应该自己拼接SQL语句！
// sql注入示例
func sqlInjectDemo(name string) {
sqlStr := fmt.Sprintf("select id, name, age from user where name='%s'", name)
fmt.Printf("SQL:%s\n", sqlStr)
var u user
err := db.QueryRow(sqlStr).Scan(&u.id, &u.name, &u.age)
if err != nil {
fmt.Printf("exec failed, err:%v\n", err)
return
}
fmt.Printf("user:%#v\n", u)
}此时以下输入字符串都可以引发SQL注入问题：
sqlInjectDemo("xxx' or 1=1#")
sqlInjectDemo("xxx' union select * from user #")
sqlInjectDemo("xxx' and (select count(*) from user) <10 #")| 数据库 | 占位符语法 |
|---|---|
| MySQL | <span style="font-family:Microsoft Yahei, Hiragino Sans GB, Helvetica, Helvetica Neue, 微软雅黑, Tahoma, Arial, sans-serif">?</span> |
| PostgreSQL | $1, $2等 |
| SQLite | ? 和$1 |
| Oracle | <span style="font-family:Microsoft Yahei, Hiragino Sans GB, Helvetica, Helvetica Neue, 微软雅黑, Tahoma, Arial, sans-serif">:name</span> |
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Utilisation du mot-clé Type dans Go
Comment implémenter une liste chaînée en go
Que sont les logiciels de programmation en langage Go ?
Comment apprendre le langage go à partir de 0 bases
Comment définir des variables dans Golang
Quelles sont les méthodes pour implémenter la surcharge d'opérateurs en langage Go ?
Quels sont les opérateurs en langage Go ?
Quelles sont les méthodes de conversion de données dans Golang ?
![Démarrez rapidement avec le framework Golang Gin [Utilisez Gin pour créer un système de messagerie instantanée simultanée de niveau million]](https://img.php.cn/upload/course/000/000/068/63a2b21046723283.jpg)
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
