golang 反射mysql查询

原标题：手把手教你学之golang反射(上)

github地址

作为静态语言，golang稍显笨拙，还好go的标准包reflect(反射)包弥补了这点不足，它提供了一系列强大的API，能够根据执行过程中对象的类型来改变程序控制流。本文将通过设计并实现一个简易的mysql orm来学习它，要求读者了解mysql基本知识，并且跟我一样至少已经接触golang两到三个月。

orm这个概念相信同学们都非常熟悉，尤其是写过rails的同学，对active_record的强大肯定深有体会(得益于的method_missing和define_method方法，少写了海量代码)，所以对orm我就不过多介绍了。本文要实现的orm只提供基本的CRUD(增删改查)和transaction(事务)功能，核心代码控制在300行左右。

如果想手把手照着写，需要先做一些准备工作。

准备工作

在本地mysql里create database orm_db，然后再create一张user表，结构如下：

1CREATETABLE`user`(

2`id`int( 10) unsignedNOTNULLAUTO_INCREMENT COMMENT'自增主键',

3`age`smallint( 10) unsignedNOTNULLDEFAULT0COMMENT'年龄',

4`first_name`varchar( 45) NOTNULLDEFAULT''COMMENT'姓',

5`last_name`varchar( 45) NOTNULLDEFAULT''COMMENT'名',

6`email`varchar( 45) NOTNULLDEFAULT''COMMENT'邮箱地址',

7`created_at`timestampNOTNULLDEFAULTCURRENT_TIMESTAMPCOMMENT'创建时间',

8`updated_at`timestampNOTNULLDEFAULTCURRENT_TIMESTAMPONUPDATECURRENT_TIMESTAMPCOMMENT'更新时间',

9PRIMARY KEY( `id`),

10KEY`idx_email`( `email`)

11) ENGINE= InnoDBDEFAULTCHARSET=utf8 COMMENT= '用户表';

同时，golang代码里定义一个与之对应的struct：

1typeUser struct{

2ID int64`json:"id"`// 自增主键

3Age int64`json:"age"`// 年龄

4FirstName string`json:"first_name"`// 姓

5LastName string`json:"last_name"`// 名

6Email string`json:"email"`// 邮箱地址

7CreatedAt time.Time `json:"created_at"`// 创建时间

8UpdatedAt time.Time `json:"updated_at"`// 更新时间

9}

与mysql交互需要用到一个go标准包和一个驱动，代码import如下：

1packageorm

2

3import(

4"database/sql"

5

6//register driver

7_ "github.com/go-sql-driver/mysql"

8)

首先按照database维度建立连接，写一个可以返回mysql连接的函数：

1//Connect db by dsn e.g. "user:password@tcp(127.0.0.1:3306)/dbname"

2funcConnect(dsn string)(*sql.DB, error){

3conn, err := sql.Open( "mysql", dsn)

4iferr != nil{

5returnnil, err

6}

7//设置连接池

8conn.SetMaxOpenConns( 100)

9conn.SetMaxIdleConns( 10)

10conn.SetConnMaxLifetime( 10* time.Minute)

11returnconn, conn.Ping()

12}

设计一个struct用于实现orm(go不是面向对象的语言，没有class)：

1//Query will build a sql

2type Query struct{

3db *sql.DB

4table string

5}

最后将通过Query拼接出sql语句与mysql交互，所以写一个绑定函数：

1//Table bind db and table

2funcTable(db *sql.DB, tableName string)func()*Query{

3returnfunc()*Query{

4return&Query{

5db: db,

6table: tableName,

7}

8}

9}

返回值是一个闭包函数，这样使用时直接调用这个闭包函数就可以获取一个绑定好的database和table的Query，比如现在有数据库orm_db和user表：

1//全局变量ormDB和users

2ormDB, _ := Connect( "user:password@tcp(127.0.0.1:3306)/orm_db")

3users := Table(ormDB, "user")

4//调用

5users().Insert(...)

准备工作到此完成，下面进入正题。

Insert方法

首先分析一下标准insert语句：

1insertintouser(first_name, last_name) values( 'Tom', 'Cat'), ( 'Tom', 'Cruise')

把sql语句中变化的部分抽象出来，其实就是key(字段)和value(值)，那么orm里的Insert方法原型就有了，如下，参数是struct或者map，因为它们都能提供键值对：

1//Insert in can be *User, []*User, map[string]interface{}

2func(q *Query)Insert(in interface{})(int64, error){

3varkeys, values [] string

4v := reflect.ValueOf(in)

5//剥离指针

6forv.Kind() == reflect.Ptr {

7v = v.Elem()

8}

9switchv.Kind() {

10casereflect.Struct:

11keys, values = sKV(v)

12casereflect.Map:

13keys, values = mKV(v)

14casereflect.Slice:

15fori := 0; i < v.Len(); i++ {

16//Kind是切片时，可以用Index()方法遍历

17sv := v.Index(i)

18forsv.Kind() == reflect.Ptr || sv.Kind() == reflect.Interface {

19sv = sv.Elem()

20}

21//切片元素不是struct或者指针，报错

22ifsv.Kind() != reflect.Struct {

23return0, errors.New( "method Insert error: in slice is not structs")

24}

25//keys只保存一次就行，因为后面的都一样了

26iflen(keys) == 0{

27keys, values = sKV(sv)

28continue

29}

30_, val := sKV(sv)

31values = append(values, val...)

32}

33default:

34return0, errors.New( "method Insert error: type error")

35}

36//todo

37//...

38}

参数in可以是一个User(前文定义好的结构体)实例的指针(或者指针集合)，也可以是一个map，这两个结构都可以提供键值对，我们通过反射来分析它的类型，然后根据类型执行相应的逻辑。

reflect包里的有两个重要结构Type和Value，Type是一个接口，定义了所有类型相关的api，reflect里的*rtype实现了这个接口，通过reflect.TypeOf函数可以获取任何传入值的*rtype。Value是一个struct，通过reflect.ValueOf函数获取，它在*rtype的基础上又封装了传入值的unsafe.Pointer类型的地址以及这个值的元数据。

在Type和Value之上还有一个Kind，它代表传入值的原始类型，比如：

1typemyInt int

2vari myInt

3t := reflect.TypeOf(i)

4k := t.Kind()

t是myInt，而k是int，Type和Kind是不同的，这一点要注意区分。

如果Type的Kind是指针、接口、切片、map等复合类型，可以调用Elem()方法获取基类型。

如果Value的Kind是指针、接口，可以调用Elem()方法获取实际值。

Value上还定义了一个Interface()方法，它是ValueOf()方法的反操作。

有了上面这些反射方法，我们可以封装一个sKV()函数，它专门处理struct类型的值，获取key(取json tag)和value：

1funcsKV(v reflect.Value)([]string, []string){

2varkeys, values [] string

3t := v.Type()

4forn := 0; n < t.NumField(); n++ {

5tf := t.Field(n)

6vf := v.Field(n)

7//忽略非导出字段

8iftf.Anonymous {

9continue

10}

11//忽略无效、零值字段

12if!vf.IsValid() || reflect.DeepEqual(vf.Interface(), reflect.Zero(vf.Type()).Interface()) {

13continue

14}

15forvf.Type().Kind() == reflect.Ptr {

16vf = vf.Elem()

17}

18//有时候根据需求会组合struct，这里处理下，支持获取嵌套的struct tag和value

19//如果字段值是time类型之外的struct，递归获取keys和values

20ifvf.Kind() == reflect.Struct && tf.Type.Name() != "Time"{

21cKeys, cValues := sKV(vf)

22keys = append(keys, cKeys...)

23values = append(values, cValues...)

24continue

25}

26//根据字段的json tag获取key，忽略无tag字段

27key := strings.Split(tf.Tag.Get( "json"), ",")[ 0]

28ifkey == ""{

29continue

30}

31value := format(vf)

32ifvalue != ""{

33keys = append(keys, key)

34values = append(values, value)

35}

36}

37returnkeys, values

38}

sKV()函数里需要格式化字符串，那么定义一个format()函数。

time.Time类型怎么转化成各种数据库的时间类型我有点拿不准，所以需要对比时间类型的值时，一律用unxi时间戳，感觉比较省事不会出错：

1funcformat(v reflect.Value)string{

2//断言出time类型直接转unix时间戳

3ift, ok := v.Interface().(time.Time); ok {

4returnfmt.Sprintf( "FROM_UNIXTIME(%d)", t.Unix())

5}

6switchv.Kind() {

7casereflect.String:

8returnfmt.Sprintf( `'%s'`, v.Interface())

9casereflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:

10returnfmt.Sprintf( `%d`, v.Interface())

11casereflect.Float32, reflect.Float64:

12returnfmt.Sprintf( `%f`, v.Interface())

13//如果是切片类型，遍历元素，递归格式化成"(, , , )"形式

14casereflect.Slice:

15varvalues [] string

16fori := 0; i < v.Len(); i++ {

17values = append(values, format(v.Index(i)))

18}

19returnfmt.Sprintf( `(%s)`, strings.Join(values, ","))

20//接口类型剥一层递归

21casereflect.Interface:

22returnformat(v.Elem())

23}

24return""

25}

map类型处理起来和struct不同，所以我们再定义一个mKV()函数，目的和sKV()一样，都是获取键值对：

1funcmKV(v reflect.Value)([]string, []string){

2varkeys, values [] string

3//获取map的key组成的切片

4mapKeys := v.MapKeys()

5for_, key := rangemapKeys {

6value := format(v.MapIndex(key))

7ifvalue != ""{

8values = append(values, value)

9keys = append(keys, key.Interface().( string))

10}

11}

12returnkeys, values

13}

利用sKV()和mKV()函数取到键值对后，就得到了insert语句中的变化部分，补全Insert()方法的todo部分：

1// Insertincan be User, * User, [] User, []* User, map[ string] interface{}

2func (q * Query) Insert( ininterface{}) (int64, error) {

3//already done

4kl := len( keys)

5vl := len( values)

6ifkl == 0|| vl == 0{

7return0, errors.New( "method Insert error: no data")

8}

9varinsertValue string

10//插入多条记录时需要用 ","拼接一下 values

11ifkl < vl {

12vartmpValues [] string

13forkl <= vl {

14ifkl%( len( keys)) == 0{

15tmpValues = append(tmpValues, fmt.Sprintf( "(%s)", strings.Join( values[kl- len( keys):kl], ",")))

16}

17kl++

18}

19insertValue = strings.Join(tmpValues, ",")

20} else{

21insertValue = fmt.Sprintf( "(%s)", strings.Join( values, ","))

22}

23query:= fmt.Sprintf( `insert into %s (%s) values %s`, q.table, strings.Join( keys, ","), insertValue)

24log.Printf( "insert sql: %s", query)

25st, err := q.DB.Prepare( query)

26iferr != nil {

27return0, err

28}

29result, err := st.Exec()

30iferr != nil {

31return0, err

32}

33returnresult.LastInsertId()

34}

原理很简单，利用反射分析参数，取键值对，然后拼接sql语句，再通过mysql驱动入库。

调用示例：

1user1 := &User{

2Age: 30,

3FirstName: "Tom",

4LastName: "Cat",

5}

6user2 := User{

7Age: 30,

8FirstName: "Tom",

9LastName: "Curise",

10}

11user3 := User{

12Age: 30,

13FirstName: "Tom",

14LastName: "Hanks",

15}

16user4 := map[string]interface{}{

17"age": 30,

18"first_name": "Tom",

19"last_name": "Zzy",

20}

21users().Insert([]interface{}{user1, user2})

22users().Insert(user3)

23users().Insert(user4)

增删改查的增部分到此完成，因为查询语句非常复杂多变，所以有了数据后，先进行查。

Select方法

先分析一下标准select语句

1selectid, age fromuserwherefirst_name = 'Tom'andlast_name = 'Cat'

可见sql语句的变量部分是select后面的字段和where后面的键值对，所以我们需要一个Where()来方法构造查询条件，并且需要一个Select()方法最后执行查询，最终形成一个链式调用效果：

1varuser[]User

2users() .Where(?) .WhereNot(?) .Limit(100) .Offset(100) .Order(" iddesc") .Only(" id", " age") .Select(& user)

所以需要改造Query如下，增加属性用于暂存链式调用中添加的值：

1//Query will build a sql

2type Query struct{

3db *sql.DB

4table string

5wheres [] string

6only [] string

7limit string

8offset string

9order string

10errs [] string

11}

为Query添加Where()方法，支持struct和map参数，同时支持传如同"age > 10"形式的字符串：

1//Where args can be string, User, *User, map[string]interface{}

2func(q *Query)Where(wheres ...interface{})*Query{

3for_, w := rangewheres {

4v := reflect.ValueOf(w)

5forv.Kind() == reflect.Ptr {

6v = v.Elem()

7}

8switchv.Kind() {

9casereflect.String:

10q.wheres = append(q.wheres, w.( string))

11casereflect.Struct:

12//todo

13casereflect.Map:

14//todo

15default:

16q.errs = append(q.errs, "method Where error: type error")

17}

18}

19returnq

20}

但是考虑到后面还会实现一个WhereNot()方法，所以把公共逻辑抽到一个where()函数里，并且直接复用之前的sKV()、mKv()函数获取键值对：

1funcwhere(eq bool, w interface{})(string, error){

2varkeys, values [] string

3v := reflect.ValueOf(w)

4forv.Kind() == reflect.Ptr {

5v = v.Elem()

6}

7switchv.Kind() {

8casereflect.String:

9returnw.( string), nil

10casereflect.Struct:

11keys, values = sKV(v)

12casereflect.Map:

13keys, values = mKV(v)

14default:

15return"", errors.New( "method Where error: type error")

16}

17iflen(keys) != len(values) {

18return"", errors.New( "method Where error: len(keys) not equal len(values))")

19}

20varwheres [] string

21//之前的format()函数里，已经将切片类型值处理成"( , , ,)“形式

22foridx, key := rangekeys {

23ifeq {

24ifstrings.HasPrefix(values[idx], "(") && strings.HasSuffix(values[idx], ")") {

25wheres = append(wheres, fmt.Sprintf( "%s in %s", key, values[idx]))

26continue

27}

28wheres = append(wheres, fmt.Sprintf( "%s = %s", key, values[idx]))

29continue

30}

31ifstrings.HasPrefix(values[idx], "(") && strings.HasSuffix(values[idx], ")") {

32wheres = append(wheres, fmt.Sprintf( "%s not in %s", key, values[idx]))

33continue

34}

35wheres = append(wheres, fmt.Sprintf( "%s != %s", key, values[idx]))

36}

37returnstrings.Join(wheres, " and "), nil

38}

Where()方法最终变成：

1//Where args can be string, User, *User, map[string]interface{}

2func(q *Query)Where(wheres ...interface{})*Query{

3for_, w := rangewheres {

4str, err := where( true, w)

5q.wheres = append(q.wheres, str)

6iferr != nil{

7//因为需要达到链式调用的效果，所以把错误都搜集起来，最后再处理

8q.errs = append(q.errs, err.Error())

9}

10}

11returnq

12}

WhereNot()把调用where()的第一个参数改成false就行了，不贴代码了。

Limit()、Offset()、Order()、Only()这几个方法也很简单：

1//Limit .

2func(q *Query)Limit(limit uint)*Query{

3q.limit = fmt.Sprintf( "limit %d", limit)

4returnq

5}

6

7//Offset .

8func(q *Query)Offset(offset uint)*Query{

9q.offset = fmt.Sprintf( "offset %d", offset)

10returnq

11}

12

13//Order .

14func(q *Query)Order(ord string)*Query{

15q.order = fmt.Sprintf( "order by %s", ord)

16returnq

17}

18

19//Only 指定需要查询的字段

20func(q *Query)Only(columns ...string)*Query{

21q.only = append(q.only, columns...)

22returnq

23}

有了上面这些条件之后，我们可以写一个toSQL()方法，把Query的属性组装成一条sql语句：

1func (q *Query) toSQL() string{

2varwherestring

3iflen(q.wheres) > 0 {

4where= fmt.Sprintf(` where%s`, strings.Join(q.wheres, " and "))

5}

6sqlStr := fmt.Sprintf(` select%s from%s %s %s %s %s`, strings.Join(q.only, ","), q.table, where, q.order, q.limit, q.offset)

7log.Printf( "select sql: %s", sqlStr)

8returnsqlStr

9}

有了sql语句我们就可以查询数据了，但是想查一个表的全部字段时，为了方便，只需要传入对应的struct，比如user表对应的User，我们就直接分析这个struct，取它的tag作为查询字段，而不需要再调用Only()方法指定字段。

另外，因为golang中的参数传递全都是值传递，要修改传入值，必须传值的指针，这里要注意一点：

1varuser User

2users.Select(&user)

3varuserPtr *User

4users.Select(user)

这两种声明方式是不同的，后者只声明了一个指针类型，是错误的。

综上，我们首先为Select()方法做一下的参数检查，确保传入值是一个正确的指针，并确保only属性有值：

1// Selectdest must be a ptr, e.g. * user, *[] user, *[]* user, * map, *[] map, * int, *[] int

2func (q * Query) Select(dest interface{}) error{

3iflen(q.errs) != 0{

4returnerrors.New(strings.Join(q.errs, "

5"))

6}

7t := reflect.TypeOf(dest)

8v := reflect.ValueOf(dest)

9typeErr := errors.New( "method Select error: type error")

10ift.Kind() != reflect.Ptr {

11returntypeErr

12}

13//如果是用 varuserPtr * User方式声明的变量，则不可取址

14if!v.Elem().CanAddr() {

15returntypeErr

16}

17t = t.Elem()

18v = v.Elem()

19//如果 only此时仍然为空，说明 Only()方法未被调用，我们从 struct上取tag填充

20iflen(q.only) == 0{

21switcht.Kind() {

22casereflect.Struct:

23ift.Name() != "Time"{

24q.only = sK(v)

25}

26casereflect.Slice:

27//获取切片的基本类型给一个局部变量

28t := t.Elem()

29ift.Kind() == reflect.Ptr {

30t = t.Elem()

31}

32ift.Kind() == reflect.Struct {

33ift.Name() != "Time"{

34q.only = sK(reflect.Zero(t))

35}

36}

37}

38}

39iflen(q.only) == 0{

40returnerrors.New( "method Select error: type error, no columns to select")

41}

42ift.Kind() != reflect.Slice {

43q.limit = "limit 1"

44}

45//todo

46}

这里只取struct的tag，不取value，我们定义一个新的sK()函数：

1funcsK(v reflect.Value)[]string{

2varkeys [] string

3t := v.Type()

4forn := 0; n < t.NumField(); n++ {

5tf := t.Field(n)

6vf := v.Field(n)

7//忽略非导出字段

8iftf.Anonymous {

9continue

10}

11forvf.Type().Kind() == reflect.Ptr {

12vf = vf.Elem()

13}

14//如果字段值是time类型之外的struct，递归获取keys

15ifvf.Kind() == reflect.Struct && tf.Type.Name() != "Time"{

16keys = append(keys, sK(vf)...)

17continue

18}

19//根据字段的json tag获取key，忽略无tag字段

20key := strings.Split(tf.Tag.Get( "json"), ",")[ 0]

21ifkey == ""{

22continue

23}

24keys = append(keys, key)

25}

26returnkeys

27}

现在sql语句已经完备了，可以执行最后的取值步骤了。

我们根据传入Select()的指针的基类型生成实际数据，对其取址后交给sql包的Scan()方法填充，然后Set()回去，所以这里需要一个address()函数用于取址：

1funcaddress(dest reflect.Value, columns []string)[]interface{} {

2dest = dest.Elem()

3t := dest.Type()

4addrs := make([] interface{}, 0)

5switcht.Kind() {

6casereflect.Struct:

7forn := 0; n < t.NumField(); n++ {

8tf := t.Field(n)

9vf := dest.Field(n)

10iftf.Anonymous {

11continue

12}

13forvf.Type().Kind() == reflect.Ptr {

14vf = vf.Elem()

15}

16//如果字段值是time类型之外的struct，递归取址

17ifvf.Kind() == reflect.Struct && tf.Type.Name() != "Time"{

18nVf := reflect.New(vf.Type())

19vf.Set(nVf.Elem())

20addrs = append(addrs, address(nVf, columns)...)

21continue

22}

23column := strings.Split(tf.Tag.Get( "json"), ",")[ 0]

24ifcolumn == ""{

25continue

26}

27//只取选定的字段的地址

28for_, col := rangecolumns {

29ifcol == column {

30addrs = append(addrs, vf.Addr().Interface())

31break

32}

33}

34}

35default:

36addrs = append(addrs, dest.Addr().Interface())

37}

38returnaddrs

39}

Value.Addr()函数可用于取址，前提是Value.CanAddr()返回true。

relfect.New()可以根据Type来new出一个Value，这个Value是一个指针，它的基值是可以取址的，把它的基值Set()到目标值上，就达到了根据Type从无到有生成对应值的目的。

因为map不能用new()函数生成，所以需要写一个用于生成map的函数setMap()：

1//map的value类型必须是interface{}，因为无类型信息，所以mysql驱动会返回一个字节切片，需要自行用[]byte断言

2func(q *Query)setMap(rows *sql.Rows, t reflect.Type)(reflect.Value, error){

3ift.Elem().Kind() != reflect.Interface {

4returnreflect.ValueOf( nil), errors.New( "method setMap error: type error, must be map[string]interface{}")

5}

6m := reflect.MakeMap(t)

7addrs := make([] interface{}, len(q.only))

8foridx := rangeq.only {

9addrs[idx] = new( interface{})

10}

11iferr := rows.Scan(addrs...); err != nil{

12returnreflect.ValueOf( nil), err

13}

14foridx, column := rangeq.only {

15//从指针剥出interface{}，再剥出实际值

16m.SetMapIndex(reflect.ValueOf(column), reflect.ValueOf(addrs[idx]).Elem().Elem())

17}

18returnm, nil

19}

reflect.MakeMap()跟make()作用差不多，它接受一个Kind是reflect.Map的Type作为参数，生成一个对应类型的map。

对于其它适用于new的类型，写一个通用的函数setElem()处理：

1//适用于基类型和struct

2func(q *Query)setElem(rows *sql.Rows, t reflect.Type)(reflect.Value, error){

3addrsErr := errors.New( "method setElem error: columns not match addresses")

4dest := reflect.New(t)

5addrs := address(dest, q.only)

6iflen(q.only) != len(addrs) {

7returnreflect.ValueOf( nil), addrsErr

8}

9iferr := rows.Scan(addrs...); err != nil{

10returnreflect.ValueOf( nil), err

11}

12returndest, nil

13}

这些函数完成后，就可以着手完善Select()里的todo部分了：

1//already done

2rows, err := q.DB.Query(q.toSQL())

3iferr != nil{

4returnerr

5}

6switcht.Kind() {

7casereflect.Slice:

8dt := t.Elem()

9fordt.Kind() == reflect.Ptr {

10dt = dt.Elem()

11}

12sl := reflect.MakeSlice(t, 0, 0)

13forrows.Next() {

14vardestination reflect.Value

15ifdt.Kind() == reflect.Map {

16destination, err = q.setMap(rows, dt)

17} else{

18destination, err = q.setElem(rows, dt)

19}

20iferr != nil{

21returnerr

22}

23//区分切片元素是否指针

24switcht.Elem().Kind() {

25casereflect.Ptr, reflect.Map:

26sl = reflect.Append(sl, destination)

27default:

28sl = reflect.Append(sl, destination.Elem())

29}

30}

31v.Set(sl)

32returnnil

33casereflect.Map:

34forrows.Next() {

35m, err := q.setMap(rows, t)

36iferr != nil{

37returnerr

38}

39v.Set(m)

40}

41returnnil

42default:

43forrows.Next() {

44destination, err := q.setElem(rows, t)

45iferr != nil{

46returnerr

47}

48v.Set(destination.Elem())

49}

50}

51returnnil

至此，Select()方法就大功告成了，部分调用方式示例：

1varuser User

2users()

3.Where( "first_name = 'Tom'", map[ string] interface{}{

4"id": [] int{ 1, 2, 3, 4},

5})

6.WhereNot(&User{LastName: "Cat"})

7.Only( "last_name")

8.Select(&user)

9

10varuserMore []User

11users().Where( "first_name = 'Tom'").Order( "id desc").Select(&userMore)

12varuserMoreP []*User

13users().Where( "first_name = 'Tom'").Select(&userMoreP)

14varlastName string

15users().Where(&User{FirstName: "Tom"}).Only( "last_name").Select(&lastName)

16varlastNames [] string

17users().Where( map[ string] interface{}{

18"first_name": "Tom",

19}).Only( "last_name").Select(&lastNames)

20varuserM map[ string] interface{}

21users().Where(&User{FirstName: "Tom"}).Only( "last_name").Select(&userM)

22varuserMS [] map[ string] interface{}

23users().Where( "age > 10").Only( "last_name", "age").Limit( 100).Select(&userMS)

篇幅有限，下半部分在次篇。

ID：Golangweb