Go 언어에서 SQL이란 무엇입니까?

SQL은 "Structured Query Language"를 말하며 데이터베이스 생성, 데이터베이스 삭제, 레코드 쿼리, 레코드 수정, 필드 추가 등 데이터베이스를 운영하기 위한 언어입니다. SQL은 관계형 데이터베이스의 표준 언어입니다. MySQL, Oracle, SQL Server, MS Access, Sybase, Informix, Postgres 등과 같은 모든 관계형 데이터베이스 관리 시스템(RDBMS)은 SQL을 표준 처리 언어로 사용합니다.

이 튜토리얼의 운영 환경: Windows 7 시스템, GO 버전 1.18, Dell G3 컴퓨터.

SQL이란 무엇입니까

SQL은 데이터베이스 생성, 데이터베이스 삭제, 레코드 조회, 레코드 수정, 필드 추가 등 데이터베이스를 운영하는 언어입니다. SQL은 ANSI에 의해 표준화된 언어이지만 구현 방식은 다양합니다.

SQL은 Structured Query Language의 약어로, 중국어로 "Structured Query Language"로 번역됩니다. SQL은 관계형 데이터베이스에 저장된 데이터를 저장, 검색 및 수정하는 데 사용되는 컴퓨터 언어입니다.

SQL은 관계형 데이터베이스의 표준 언어입니다. MySQL, Oracle, SQL Server, MS Access, Sybase, Informix, Postgres 등과 같은 모든 관계형 데이터베이스 관리 시스템(RDBMS)은 SQL을 표준 처리 언어로 사용합니다.

SQL의 목적

SQL은 다음과 같은 용도로 인해 널리 사용됩니다.

• 사용자가 관계형 데이터베이스 시스템의 데이터에 액세스할 수 있도록 허용합니다.

• 사용자가 데이터를 설명할 수 있도록 허용합니다.

• SQL 모듈, 라이브러리 또는 전처리기를 다른 프로그래밍 언어에 포함할 수 있습니다.

• 사용자가 데이터베이스, 테이블 및 데이터 항목(레코드)을 생성하고 삭제할 수 있습니다.

• 사용자가 데이터베이스에서 뷰, 저장 프로시저 및 함수를 생성할 수 있습니다.

• 사용자가 테이블, 저장 프로시저 및 뷰에 대한 권한을 설정할 수 있습니다.

• Go 언어 운영 데이터베이스(MySQL)

Go 언어 표준 라이브러리는 데이터베이스 운영을 위한 SQL 라이브러리를 제공하며, SQL 언어를 사용하여 데이터베이스를 운영할 수 있습니다.

1.1 Connect

1.1.1 종속성 다운로드

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

1.1.2 MySQL 드라이버 사용

func Open(driverName, dataSourceName string) (*DB, error)

OpenOpen a dirverName

,

dataSourceName으로 지정됨 지정된 데이터 소스에는 일반적으로 최소한 데이터베이스 파일 이름과 연결에 필요한 기타 정보가 포함됩니다.

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判断的下面
}

1.1.3 연결 초기화

Open 함수는 해당 매개변수가 올바른 형식인지 확인할 뿐 실제로 데이터베이스에 대한 연결을 생성하지는 않습니다. 데이터 소스의 이름이 실제이고 유효한지

확인하려면

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
    }
}

1.1.4SetMaxOpenConns

SetMaxOpenConns최대값을 설정해야 합니다. 데이터베이스 연결 수 . n이 0보다 크고 최대 유휴 연결 수보다 작은 경우,

최대 유휴 연결 수는 최대 열린 연결 수

제한과 일치하도록 감소됩니다. n<=0인 경우 열린 연결의 최대 개수는 제한되지 않습니다. SetMaxOpenConns设置与数据库建立连接的最大数目。 如果n大于0且小于最大闲置连接数，会将最大闲置连接数减小到匹配最大开启连接数的限制。 如果n<=0，不会限制最大开启连接数，默认为0（无限制）

1.1.5SetMaxIdleConns

func (db *DB) SetMaxIdleConns(n int)

连接池中的最大闲置连接数

如果n大于最大开启连接数，则新的最大闲置连接数会减小到匹配最大开启连接数的限制。 如果n<=0，不会保留闲置连接。

1.2CRUD

1.2.1 建库建表

我们先在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;

1.2.2 查询

单行查询

单行查询db.QueryRow()执行一次查询，并期望返回最多一行结果（即Row）。QueryRow总是返回非nil的值，直到返回值的Scan方法被调用时，才会返回被延迟的错误。（如：未找到结果）

func (db *DB) QueryRow(query string, args ...interface{}) *Row

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 (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)
    }
}

1.2.3 插入数据

插入、更新和删除操作都使用Exec기본값은 0(제한 없음)입니다.

1.1.5SetMaxIdleConns

func (db *DB) Exec(query string, args ...interface{}) (Result, error)

The 최대 유휴 연결 풀 번호

의 연결 n

이 최대 열린 연결 수🎜보다 큰 경우 새로운 최대 유휴 연결 수는 최대 열린 연결 수🎜의 제한 🎜과 일치하도록 줄어듭니다. 🎜n<=0이면 유휴 연결 🎜이 유지되지 않습니다. 🎜🎜🎜🎜1.2CRUD🎜🎜🎜🎜1.2.1 데이터베이스 및 테이블 구축🎜🎜🎜먼저 MySQL에서 sql_test라는 데이터베이스를 생성합니다🎜

// 插入数据
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)
}

🎜🎜🎜1.2.2 Query🎜🎜

🎜단일 행 쿼리🎜

🎜Single -row query db.QueryRow()는 쿼리를 실행하고 최대 한 행의 결과(예: Row)를 반환할 것으로 예상합니다. QueryRow는 항상 nil이 아닌 값을 반환하며 값을 반환하는 Scan 메서드가 호출될 때까지 지연된 오류를 반환하지 않습니다. (예: 결과 없음)🎜

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)

🎜🎜다중 행 쿼리🎜

<a id="_145">// 预处理查询示例
func prepareQueryDemo() {
    sqlStr := &quot;select id, name, age from user where id &gt; ?&quot;
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf(&quot;prepare failed, err:%v\n&quot;, err)
        return
    }
    defer stmt.Close()
    rows, err := stmt.Query(0)
    if err != nil {
        fmt.Printf(&quot;query failed, err:%v\n&quot;, err)
        return
    }
    defer rows.Close()
    // 循环读取结果集中的数据
    for rows.Next() {
        var u user
        err := rows.Scan(&amp;u.id, &amp;u.name, &amp;u.age)
        if err != nil {
            fmt.Printf(&quot;scan failed, err:%v\n&quot;, err)
            return
        }
        fmt.Printf(&quot;id:%d name:%s age:%d\n&quot;, u.id, u.name, u.age)
    }
}</a>

<a id="_145">// 预处理插入示例
func prepareInsertDemo() {
    sqlStr := &quot;insert into user(name, age) values (?,?)&quot;
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf(&quot;prepare failed, err:%v\n&quot;, err)
        return
    }
    defer stmt.Close()
    _, err = stmt.Exec(&quot;小王子&quot;, 18)
    if err != nil {
        fmt.Printf(&quot;insert failed, err:%v\n&quot;, err)
        return
    }
    _, err = stmt.Exec(&quot;沙河娜扎&quot;, 18)
    if err != nil {
        fmt.Printf(&quot;insert failed, err:%v\n&quot;, err)
        return
    }
    fmt.Println(&quot;insert success.&quot;)
}</a>

🎜🎜🎜1.2.3 데이터 삽입🎜🎜 🎜 삽입, 업데이트 및 삭제 작업은 모두 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)
}

🎜Exec는 명령(쿼리, 삭제, 업데이트, 삽입 등 포함)을 실행하고 반환된 결과는 실행된 SQL 명령의 요약입니다. 매개변수 args는 쿼리의 자리 표시자 매개변수를 나타냅니다. 🎜🎜데이터 삽입을 위한 구체적인 샘플 코드는 다음과 같습니다. 🎜

sqlInjectDemo("xxx' or 1=1#")
sqlInjectDemo("xxx' union select * from user #")
sqlInjectDemo("xxx' and (select count(*) from user) <10 #")

🎜🎜🎜🎜1.2.4 데이터 업데이트🎜🎜🎜데이터 업데이트를 위한 구체적인 샘플 코드는 다음과 같습니다. 🎜

// 更新数据
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)
}

1.2.5删除数据

具体删除数据的示例代码如下：

// 删除数据
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()
}

1.3MySQL预处理

1.3.1什么是预处理？

普通SQL语句执行过程：

• 客户端对SQL语句进行占位符替换得到完整的SQL语句。

• 客户端发送完整SQL语句到MySQL服务端

• MySQL服务端执行完整的SQL语句并将结果返回给客户端。

预处理执行过程：

• 把SQL语句分成两部分，命令部分与数据部分。

• 先把命令部分发送给MySQL服务端，MySQL服务端进行SQL预处理。

• 然后把数据部分发送给MySQL服务端，MySQL服务端对SQL语句进行占位符替换。

• MySQL服务端执行完整的SQL语句并将结果返回给客户端

1.3.2为什么要预处理？

• 优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。

• 避免SQL注入问题。

1.3.3 Go实现MySQL预处理

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.")
}

总结 其实就多了一个db.Prepare(sqlStr)

1.3.4 SQL注入问题

我们任何时候都不应该自己拼接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>

【相关推荐：Go视频教程、编程教学】

위 내용은 Go 언어에서 SQL이란 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!