10.Beego框架ORM原生SQL查询

Leefs 2022-08-05 PM 2745℃ 2条

[TOC]

### 一、概述

beego orm包除了支持model查询的方式，也支持直接编写sql语句的方式查询数据。

sql原生查询有如下特点:

- 使用 Raw SQL 查询，无需使用 ORM 表定义
- 多数据库，都可直接使用占位符号 `?`，自动转换
- 查询时的参数，支持使用 Model Struct 和 Slice, Array

在遇到比较复杂的查询的时候，使用sql语句更加灵活和直观，也比较容易把控sql查询的性能。

### 二、方法说明

#### Exec

执行 sql 语句，返回 sql.Result 对象

```go
res, err := o.Raw("UPDATE user SET name = ?", "your").Exec()
if err == nil {
    num, _ := res.RowsAffected()
    fmt.Println("mysql row affected nums: ", num)
}
```

#### QueryRow

查询数据主要通过QueryRow和QueryRows两个函数，分别对应查询一条数据还是多条数据，这两个函数都支持将查询结果保存到struct中。

```go
type User struct {
    Id       int
    UserName string
}
var user User
err := o.Raw("SELECT id, user_name FROM user WHERE id = ?", 1).QueryRow(&user)
```

#### QueryRows

QueryRows 支持的对象还有 map 规则是和 QueryRow 一样的，但都是 slice

```go
type User struct {
    Id       int
    UserName string
}
var users []User
num, err := o.Raw("SELECT id, user_name FROM user WHERE id = ?", 1).QueryRows(&users)
if err == nil {
    fmt.Println("user nums: ", num)
}
```

#### SetArgs

创建一个 **RawSeter**

```

// RawSeter raw query seter
// create From Ormer.Raw
// for example:
//  sql := fmt.Sprintf("SELECT %sid%s,%sname%s FROM %suser%s WHERE id = ?",Q,Q,Q,Q,Q,Q)
//  rs := Ormer.Raw(sql, 1)
type RawSeter interface {
    // execute sql and get result
    Exec() (sql.Result, error)
    // query data and map to container
    // for example:
    //    var name string
    //    var id int
    //    rs.QueryRow(&id,&name) // id==2 name=="slene"
    QueryRow(containers ...interface{}) error
    // query data rows and map to container
    //    var ids []int
    //    var names []int
    //    query = fmt.Sprintf("SELECT 'id','name' FROM %suser%s", Q, Q)
    //    num, err = dORM.Raw(query).QueryRows(&ids,&names) // ids=>{1,2},names=>{"nobody","slene"}
    QueryRows(containers ...interface{}) (int64, error)
    SetArgs(...interface{}) RawSeter
    // query data to []map[string]interface
    // see QuerySeter's Values
    Values(container *[]Params, cols ...string) (int64, error)
    // query data to [][]interface
    // see QuerySeter's ValuesList
    ValuesList(container *[]ParamsList, cols ...string) (int64, error)
    // query data to []interface
    // see QuerySeter's ValuesFlat
    ValuesFlat(container *ParamsList, cols ...string) (int64, error)
    // query all rows into map[string]interface with specify key and value column name.
    // keyCol = "name", valueCol = "value"
    // table data
    // name  | value
    // total | 100
    // found | 200
    // to map[string]interface{}{
    //     "total": 100,
    //     "found": 200,
    // }
    RowsToMap(result *Params, keyCol, valueCol string) (int64, error)
    // query all rows into struct with specify key and value column name.
    // keyCol = "name", valueCol = "value"
    // table data
    // name  | value
    // total | 100
    // found | 200
    // to struct {
    //     Total int
    //     Found int
    // }
    RowsToStruct(ptrStruct interface{}, keyCol, valueCol string) (int64, error)
    // return prepared raw statement for used in times.
    // for example:
    //     pre, err := dORM.Raw("INSERT INTO tag (name) VALUES (?)").Prepare()
    //     r, err := pre.Exec("name1") // INSERT INTO tag (name) VALUES (`name1`)
    Prepare() (RawPreparer, error)
}
```

通过SQL更新用户名称

```
o := orm.NewOrm()
var r RawSeter
r = o.Raw("UPDATE user SET name = ? WHERE name = ?", "testing", "Leefs")
```

改变 Raw(sql, args…) 中的 args 参数，返回一个新的 RawSeter

用于单条 sql 语句，重复利用，替换参数然后执行。

```go
res, err := r.SetArgs("arg1", "arg2").Exec()
res, err := r.SetArgs("arg1", "arg2").Exec()
...
```

#### Values / ValuesList / ValuesFlat

Raw SQL 查询获得的结果集 Value 为 `string` 类型，NULL 字段的值为空 ``

##### Values

返回结果集的 key => value 值

```go
var maps []orm.Params
num, err := o.Raw("SELECT user_name FROM user WHERE status = ?", 1).Values(&maps)
if err == nil && num > 0 {
    fmt.Println(maps[0]["user_name"]) // Leefs
}
```

##### ValuesList

返回结果集 slice

```go
var lists []orm.ParamsList
num, err := o.Raw("SELECT user_name FROM user WHERE status = ?", 1).ValuesList(&lists)
if err == nil && num > 0 {
    fmt.Println(lists[0][0]) // Leefs
}
```

##### ValuesFlat

返回单一字段的平铺 slice 数据

```go
var list orm.ParamsList
num, err := o.Raw("SELECT id FROM user WHERE id < ?", 10).ValuesFlat(&list)
if err == nil && num > 0 {
    fmt.Println(list) // []{"1","2","3",...}
}
```

#### RowsToMap

SQL 查询结果是这样

| name  | value |
| :---- | :---- |
| total | 100   |
| found | 200   |

查询结果匹配到 map 里

```go
res := make(orm.Params)
nums, err := o.Raw("SELECT name, value FROM options_table").RowsToMap(&res, "name", "value")
// res is a map[string]interface{}{
//    "total": 100,
//    "found": 200,
// }
```

#### RowsToStruct

SQL 查询结果是这样

| name  | value |
| :---- | :---- |
| total | 100   |
| found | 200   |

查询结果匹配到 struct 里

```go
type Options struct {
    Total int
    Found int
}
res := new(Options)
nums, err := o.Raw("SELECT name, value FROM options_table").RowsToStruct(res, "name", "value")
fmt.Println(res.Total) // 100
fmt.Println(res.Found) // 200
```

> 匹配支持的名称转换为 snake -> camel, eg: SELECT user_name … 需要你的 struct 中定义有 UserName

#### Prepare

用于一次 prepare 多次 exec，以提高批量执行的速度。

```go
p, err := o.Raw("UPDATE user SET name = ? WHERE name = ?").Prepare()
res, err := p.Exec("testing", "leefs")
res, err  = p.Exec("testing", "leefs2")
...
...
p.Close() // 别忘记关闭 statement
```

### 二、示例

#### 2.1 执行插入、更新、删除SQL语句

执行insert、update、delete语句，需要使用Exec函数，执行后返回 sql.Result 对象，通过sql.Result对象可以查询最新插入的自增ID，影响行数。

```go
// 创建orm对象
o := orm.NewOrm()

// insert
// 使用Raw函数设置sql语句和参数
res, err := o.Raw("insert into users(username, password) values(?, ?)", "Leefs", "123456").Exec()

// 插入数据的自增id
id := res.LastInsertId()

// update
res, err := o.Raw("update users set password=? where username=?", "654321", "Leefs").Exec()

// 获取更新数据影响的行数
rows := res.RowsAffected()

// delete
o.Raw("delete from users where username=?", "Leefs").Exec()
```

#### 2.2 查询语句

+ 查询一行数据

```go
type User struct {
    Id       int
    Username string
}

var user User
err := o.Raw("SELECT id, username FROM users WHERE id = ?", 1).QueryRow(&user)
```

+ 查询多行数据

```go
type User struct {
    Id       int
    UserName string
}

var users []User

num, err := o.Raw("SELECT id, username FROM users WHERE id > ? and id < ?", 1, 100).QueryRows(&users)

if err == nil {
    fmt.Println("查询总数: ", num)
}
```

*附参考文章链接*

*https://www.bookstack.cn/read/beego-2.0-zh/mvc-model-rawsql.md*

*https://www.tizi365.com/archives/129.html*

标签: Beego

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/2298.html

上一篇 09.Beego框架ORM高级查询

下一篇 FileBeat自动关闭问题解决

10.Beego框架ORM原生SQL查询

评论已关闭

栏目分类

标签云

友情链接申请

10.Beego框架ORM原生SQL查询

评论已关闭

 栏目分类

标签云

友情链接申请

栏目分类

标签云

友情链接申请