From 79f6b898a1559af01e25636e35988031a5038ef0 Mon Sep 17 00:00:00 2001
From: Rennbon <343688972@qq.com>
Date: Fri, 3 Dec 2021 19:59:07 +0800
Subject: [PATCH 1/7] no message

---
 go.mod       |   5 +-
 go.sum       |  10 ++++
 rows.go      | 130 +++++++++++++++++++++++++++++++++++++++++++++++++++
 rows_test.go |  51 ++++++++++++++++++++
 4 files changed, 195 insertions(+), 1 deletion(-)

diff --git a/go.mod b/go.mod
index 6f58b70..2a23532 100644
--- a/go.mod
+++ b/go.mod
@@ -2,4 +2,7 @@ module github.com/DATA-DOG/go-sqlmock
 
 go 1.15
 
-require github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46
+require (
+	github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46
+	github.com/stretchr/testify v1.7.0 // indirect
+)
diff --git a/go.sum b/go.sum
index a21f637..8c53630 100644
--- a/go.sum
+++ b/go.sum
@@ -1,2 +1,12 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46 h1:veS9QfglfvqAw2e+eeNT/SbGySq8ajECXJ9e4fPoLhY=
 github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/rows.go b/rows.go
index 941544b..cbc9b3d 100644
--- a/rows.go
+++ b/rows.go
@@ -4,9 +4,12 @@ import (
 	"bytes"
 	"database/sql/driver"
 	"encoding/csv"
+	"errors"
 	"fmt"
 	"io"
+	"reflect"
 	"strings"
+	"time"
 )
 
 const invalidate = "☠☠☠ MEMORY OVERWRITTEN ☠☠☠ "
@@ -127,6 +130,133 @@ type Rows struct {
 	closeErr  error
 }
 
+// NewRowsFromStruct new Rows from struct reflect with tagName
+// tagName default "json"
+func NewRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
+	if m == nil {
+		return nil, errors.New("param m is nil")
+	}
+	val := reflect.ValueOf(m).Elem()
+	if val.Kind() != reflect.Struct {
+		return nil, errors.New("param type must be struct")
+	}
+	num := val.NumField()
+	if num == 0 {
+		return nil, errors.New("no properties available")
+	}
+	columns := make([]string, 0, num)
+	var values []driver.Value
+	tag := "json"
+	if len(tagName) > 0 {
+		tag = tagName[0]
+	}
+	for i := 0; i < num; i++ {
+		f := val.Type().Field(i)
+		column := f.Tag.Get(tag)
+		if len(column) > 0 {
+			columns = append(columns, column)
+			values = append(values, val.Field(i))
+		}
+	}
+	if len(columns) == 0 {
+		return nil, errors.New("tag not match")
+	}
+	rows := &Rows{
+		cols:      columns,
+		nextErr:   make(map[int]error),
+		converter: reflectTypeConverter{},
+	}
+	return rows.AddRow(values...), nil
+}
+
+var timeKind = reflect.TypeOf(time.Time{}).Kind()
+
+type reflectTypeConverter struct{}
+
+func (reflectTypeConverter) ConvertValue(v interface{}) (driver.Value, error) {
+	rv := v.(reflect.Value)
+	switch rv.Kind() {
+	case reflect.Ptr:
+		// indirect pointers
+		if rv.IsNil() {
+			return nil, nil
+		} else {
+			return driver.DefaultParameterConverter.ConvertValue(rv.Elem().Interface())
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return rv.Int(), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
+		return int64(rv.Uint()), nil
+	case reflect.Uint64:
+		u64 := rv.Uint()
+		if u64 >= 1<<63 {
+			return nil, fmt.Errorf("uint64 values with high bit set are not supported")
+		}
+		return int64(u64), nil
+	case reflect.Float32, reflect.Float64:
+		return rv.Float(), nil
+	case reflect.Bool:
+		return rv.Bool(), nil
+	case reflect.Slice:
+		ek := rv.Type().Elem().Kind()
+		if ek == reflect.Uint8 {
+			return rv.Bytes(), nil
+		}
+		return nil, fmt.Errorf("unsupported type %T, a slice of %s", v, ek)
+	case reflect.String:
+		return rv.String(), nil
+	case timeKind:
+		return rv.Interface().(time.Time), nil
+	}
+	return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
+}
+
+// NewRowsFromStructs new Rows from struct slice reflect with tagName
+// NOTE: arr must be of the same type
+// tagName default "json"
+func NewRowsFromStructs(tagName string, arr ...interface{}) (*Rows, error) {
+	if len(arr) == 0 {
+		return nil, errors.New("param arr is nil")
+	}
+	typ := reflect.TypeOf(arr[0]).Elem()
+	if typ.Kind() != reflect.Struct {
+		return nil, errors.New("param type must be struct")
+	}
+	if typ.NumField() == 0 {
+		return nil, errors.New("no properties available")
+	}
+	var columns []string
+	tag := "json"
+	if len(tagName) > 0 {
+		tag = tagName
+	}
+	for i := 0; i < typ.NumField(); i++ {
+		f := typ.Field(i)
+		column := f.Tag.Get(tag)
+		if len(column) > 0 {
+			columns = append(columns, column)
+		}
+	}
+	if len(columns) == 0 {
+		return nil, errors.New("tag not match")
+	}
+	rows := &Rows{
+		cols:      columns,
+		nextErr:   make(map[int]error),
+		converter: reflectTypeConverter{},
+	}
+	for _, m := range arr {
+		v := m
+		val := reflect.ValueOf(v).Elem()
+		var values []driver.Value
+		for _, column := range columns {
+			values = append(values, val.FieldByName(column))
+		}
+		rows.AddRow(values...)
+	}
+	return rows, nil
+}
+
 // NewRows allows Rows to be created from a
 // sql driver.Value slice or from the CSV string and
 // to be used as sql driver.Rows.
diff --git a/rows_test.go b/rows_test.go
index ef17521..a75de52 100644
--- a/rows_test.go
+++ b/rows_test.go
@@ -5,7 +5,9 @@ import (
 	"database/sql"
 	"database/sql/driver"
 	"fmt"
+	"github.com/stretchr/testify/assert"
 	"testing"
+	"time"
 )
 
 const invalid = `☠☠☠ MEMORY OVERWRITTEN ☠☠☠ `
@@ -753,3 +755,52 @@ func ExampleRows_AddRows() {
 	// Output: scanned id: 1 and title: one
 	// scanned id: 2 and title: two
 }
+
+type MockStruct struct {
+	Type       int       `mock:"type"`
+	Name       string    `mock:"name"`
+	CreateTime time.Time `mock:"createTime"`
+}
+
+func TestNewRowsFromStruct(t *testing.T) {
+	m := &MockStruct{
+		Type:       1,
+		Name:       "sqlMock",
+		CreateTime: time.Now(),
+	}
+	excepted := NewRows([]string{"type", "name", "createTime"}).AddRow(m.Type, m.Name, m.CreateTime)
+
+	actual, err := NewRowsFromStruct(m, "mock")
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.EqualValues(t, excepted.cols, actual.cols)
+	assert.EqualValues(t, excepted.rows, actual.rows)
+	assert.EqualValues(t, excepted.def, actual.def)
+}
+
+func TestNewRowsFromStructs(t *testing.T) {
+	m1 := &MockStruct{
+		Type:       1,
+		Name:       "sqlMock1",
+		CreateTime: time.Now(),
+	}
+	m2 := &MockStruct{
+		Type:       2,
+		Name:       "sqlMock2",
+		CreateTime: time.Now(),
+	}
+	arr := []*MockStruct{m1, m2}
+
+	excepted := NewRows([]string{"type", "name", "createTime"})
+	for _, v := range arr {
+		excepted.AddRow(v.Type, v.Name, v.CreateTime)
+	}
+	actual, err := NewRowsFromStructs("mock", m1, m2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.EqualValues(t, excepted.cols, actual.cols)
+	assert.EqualValues(t, excepted.rows, actual.rows)
+	assert.EqualValues(t, excepted.def, actual.def)
+}

From eb54fbc286096badc27ca68b2355f9b352b8a7f0 Mon Sep 17 00:00:00 2001
From: Rennbon <343688972@qq.com>
Date: Tue, 7 Dec 2021 14:24:05 +0800
Subject: [PATCH 2/7] feat: create rows with slices

Author:    Rennbon <343688972@qq.com>
---
 rows.go      | 61 ++++++++++------------------------------------------
 rows_test.go |  2 +-
 2 files changed, 12 insertions(+), 51 deletions(-)

diff --git a/rows.go b/rows.go
index cbc9b3d..0d40545 100644
--- a/rows.go
+++ b/rows.go
@@ -9,7 +9,6 @@ import (
 	"io"
 	"reflect"
 	"strings"
-	"time"
 )
 
 const invalidate = "☠☠☠ MEMORY OVERWRITTEN ☠☠☠ "
@@ -155,7 +154,7 @@ func NewRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
 		column := f.Tag.Get(tag)
 		if len(column) > 0 {
 			columns = append(columns, column)
-			values = append(values, val.Field(i))
+			values = append(values, val.Field(i).Interface())
 		}
 	}
 	if len(columns) == 0 {
@@ -164,53 +163,11 @@ func NewRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
 	rows := &Rows{
 		cols:      columns,
 		nextErr:   make(map[int]error),
-		converter: reflectTypeConverter{},
+		converter: driver.DefaultParameterConverter,
 	}
 	return rows.AddRow(values...), nil
 }
 
-var timeKind = reflect.TypeOf(time.Time{}).Kind()
-
-type reflectTypeConverter struct{}
-
-func (reflectTypeConverter) ConvertValue(v interface{}) (driver.Value, error) {
-	rv := v.(reflect.Value)
-	switch rv.Kind() {
-	case reflect.Ptr:
-		// indirect pointers
-		if rv.IsNil() {
-			return nil, nil
-		} else {
-			return driver.DefaultParameterConverter.ConvertValue(rv.Elem().Interface())
-		}
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return rv.Int(), nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
-		return int64(rv.Uint()), nil
-	case reflect.Uint64:
-		u64 := rv.Uint()
-		if u64 >= 1<<63 {
-			return nil, fmt.Errorf("uint64 values with high bit set are not supported")
-		}
-		return int64(u64), nil
-	case reflect.Float32, reflect.Float64:
-		return rv.Float(), nil
-	case reflect.Bool:
-		return rv.Bool(), nil
-	case reflect.Slice:
-		ek := rv.Type().Elem().Kind()
-		if ek == reflect.Uint8 {
-			return rv.Bytes(), nil
-		}
-		return nil, fmt.Errorf("unsupported type %T, a slice of %s", v, ek)
-	case reflect.String:
-		return rv.String(), nil
-	case timeKind:
-		return rv.Interface().(time.Time), nil
-	}
-	return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
-}
-
 // NewRowsFromStructs new Rows from struct slice reflect with tagName
 // NOTE: arr must be of the same type
 // tagName default "json"
@@ -226,15 +183,18 @@ func NewRowsFromStructs(tagName string, arr ...interface{}) (*Rows, error) {
 		return nil, errors.New("no properties available")
 	}
 	var columns []string
+	var idx []int
 	tag := "json"
 	if len(tagName) > 0 {
 		tag = tagName
 	}
+
 	for i := 0; i < typ.NumField(); i++ {
 		f := typ.Field(i)
 		column := f.Tag.Get(tag)
 		if len(column) > 0 {
 			columns = append(columns, column)
+			idx = append(idx, i)
 		}
 	}
 	if len(columns) == 0 {
@@ -243,14 +203,15 @@ func NewRowsFromStructs(tagName string, arr ...interface{}) (*Rows, error) {
 	rows := &Rows{
 		cols:      columns,
 		nextErr:   make(map[int]error),
-		converter: reflectTypeConverter{},
+		converter: driver.DefaultParameterConverter,
 	}
+
 	for _, m := range arr {
-		v := m
-		val := reflect.ValueOf(v).Elem()
+		val := reflect.ValueOf(m).Elem()
 		var values []driver.Value
-		for _, column := range columns {
-			values = append(values, val.FieldByName(column))
+		for _, i := range idx {
+			// NOTE: field by name ptr nil
+			values = append(values, val.Field(i).Interface())
 		}
 		rows.AddRow(values...)
 	}
diff --git a/rows_test.go b/rows_test.go
index a75de52..f88a9ef 100644
--- a/rows_test.go
+++ b/rows_test.go
@@ -796,7 +796,7 @@ func TestNewRowsFromStructs(t *testing.T) {
 	for _, v := range arr {
 		excepted.AddRow(v.Type, v.Name, v.CreateTime)
 	}
-	actual, err := NewRowsFromStructs("mock", m1, m2)
+	actual, err := NewRowsFromStructs("mock", arr[0],arr[1])
 	if err != nil {
 		t.Fatal(err)
 	}

From 462cf4ba6adbce4164c42d4be6978222c3c7ac04 Mon Sep 17 00:00:00 2001
From: Rennbon <343688972@qq.com>
Date: Tue, 7 Dec 2021 21:07:57 +0800
Subject: [PATCH 3/7] refact: rm testify

Author:    Rennbon <343688972@qq.com>
---
 go.mod       |  5 +----
 go.sum       | 10 ----------
 rows_test.go | 26 ++++++++++++++++++--------
 3 files changed, 19 insertions(+), 22 deletions(-)

diff --git a/go.mod b/go.mod
index 2a23532..6f58b70 100644
--- a/go.mod
+++ b/go.mod
@@ -2,7 +2,4 @@ module github.com/DATA-DOG/go-sqlmock
 
 go 1.15
 
-require (
-	github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46
-	github.com/stretchr/testify v1.7.0 // indirect
-)
+require github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46
diff --git a/go.sum b/go.sum
index 8c53630..a21f637 100644
--- a/go.sum
+++ b/go.sum
@@ -1,12 +1,2 @@
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46 h1:veS9QfglfvqAw2e+eeNT/SbGySq8ajECXJ9e4fPoLhY=
 github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/rows_test.go b/rows_test.go
index f88a9ef..c8cb614 100644
--- a/rows_test.go
+++ b/rows_test.go
@@ -5,7 +5,7 @@ import (
 	"database/sql"
 	"database/sql/driver"
 	"fmt"
-	"github.com/stretchr/testify/assert"
+	"reflect"
 	"testing"
 	"time"
 )
@@ -774,9 +774,14 @@ func TestNewRowsFromStruct(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	assert.EqualValues(t, excepted.cols, actual.cols)
-	assert.EqualValues(t, excepted.rows, actual.rows)
-	assert.EqualValues(t, excepted.def, actual.def)
+	same := reflect.DeepEqual(excepted.cols, actual.cols)
+	if !same {
+		t.Fatal("custom tag reflect failed")
+	}
+	same = reflect.DeepEqual(excepted.rows, actual.rows)
+	if !same {
+		t.Fatal("reflect value from tag failed")
+	}
 }
 
 func TestNewRowsFromStructs(t *testing.T) {
@@ -796,11 +801,16 @@ func TestNewRowsFromStructs(t *testing.T) {
 	for _, v := range arr {
 		excepted.AddRow(v.Type, v.Name, v.CreateTime)
 	}
-	actual, err := NewRowsFromStructs("mock", arr[0],arr[1])
+	actual, err := NewRowsFromStructs("mock", arr[0], arr[1])
 	if err != nil {
 		t.Fatal(err)
 	}
-	assert.EqualValues(t, excepted.cols, actual.cols)
-	assert.EqualValues(t, excepted.rows, actual.rows)
-	assert.EqualValues(t, excepted.def, actual.def)
+	same := reflect.DeepEqual(excepted.cols, actual.cols)
+	if !same {
+		t.Fatal("custom tag reflect failed")
+	}
+	same = reflect.DeepEqual(excepted.rows, actual.rows)
+	if !same {
+		t.Fatal("reflect value from tag failed")
+	}
 }

From 9c4a2076068934e76c62ca0d8398117ddc42c74e Mon Sep 17 00:00:00 2001
From: Rennbon <343688972@qq.com>
Date: Sun, 12 Dec 2021 18:46:31 +0800
Subject: [PATCH 4/7] refact: merge struct and slice/array

---
 rows.go      | 48 +++++++++++++++++++++++++++++++++---------------
 rows_test.go | 18 ++++++++----------
 2 files changed, 41 insertions(+), 25 deletions(-)

diff --git a/rows.go b/rows.go
index 0d40545..00d9310 100644
--- a/rows.go
+++ b/rows.go
@@ -131,14 +131,14 @@ type Rows struct {
 
 // NewRowsFromStruct new Rows from struct reflect with tagName
 // tagName default "json"
-func NewRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
-	if m == nil {
+func newRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
+	/*	if m == nil {
 		return nil, errors.New("param m is nil")
-	}
+	}*/
 	val := reflect.ValueOf(m).Elem()
-	if val.Kind() != reflect.Struct {
+	/*	if val.Kind() != reflect.Struct {
 		return nil, errors.New("param type must be struct")
-	}
+	}*/
 	num := val.NumField()
 	if num == 0 {
 		return nil, errors.New("no properties available")
@@ -168,27 +168,46 @@ func NewRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
 	return rows.AddRow(values...), nil
 }
 
+// NewRowsFromInterface new Rows from struct or slice or array reflect with tagName
+// NOTE: arr/slice must be of the same type
+// tagName default "json"
+func NewRowsFromInterface(m interface{}, tagName string) (*Rows, error) {
+	kind := reflect.TypeOf(m).Elem().Kind()
+	if kind == reflect.Ptr {
+		kind = reflect.TypeOf(m).Kind()
+	}
+	switch kind {
+	case reflect.Slice, reflect.Array:
+		return newRowsFromSliceOrArray(m, tagName)
+	case reflect.Struct:
+		return newRowsFromStruct(m, tagName)
+	default:
+		return nil, errors.New("the type m must in struct or slice or array")
+	}
+}
+
 // NewRowsFromStructs new Rows from struct slice reflect with tagName
 // NOTE: arr must be of the same type
 // tagName default "json"
-func NewRowsFromStructs(tagName string, arr ...interface{}) (*Rows, error) {
-	if len(arr) == 0 {
-		return nil, errors.New("param arr is nil")
+func newRowsFromSliceOrArray(m interface{}, tagName string) (*Rows, error) {
+	vals := reflect.ValueOf(m)
+	if vals.Len() == 0 {
+		return nil, errors.New("the len of m is zero")
 	}
-	typ := reflect.TypeOf(arr[0]).Elem()
+	typ := reflect.TypeOf(vals.Index(0).Interface()).Elem()
 	if typ.Kind() != reflect.Struct {
 		return nil, errors.New("param type must be struct")
 	}
 	if typ.NumField() == 0 {
 		return nil, errors.New("no properties available")
 	}
-	var columns []string
+
 	var idx []int
 	tag := "json"
 	if len(tagName) > 0 {
 		tag = tagName
 	}
-
+	columns := make([]string, 0, typ.NumField())
 	for i := 0; i < typ.NumField(); i++ {
 		f := typ.Field(i)
 		column := f.Tag.Get(tag)
@@ -205,10 +224,9 @@ func NewRowsFromStructs(tagName string, arr ...interface{}) (*Rows, error) {
 		nextErr:   make(map[int]error),
 		converter: driver.DefaultParameterConverter,
 	}
-
-	for _, m := range arr {
-		val := reflect.ValueOf(m).Elem()
-		var values []driver.Value
+	for i := 0; i < vals.Len(); i++ {
+		val := vals.Index(i).Elem()
+		values := make([]driver.Value, 0, len(idx))
 		for _, i := range idx {
 			// NOTE: field by name ptr nil
 			values = append(values, val.Field(i).Interface())
diff --git a/rows_test.go b/rows_test.go
index c8cb614..5557396 100644
--- a/rows_test.go
+++ b/rows_test.go
@@ -762,7 +762,7 @@ type MockStruct struct {
 	CreateTime time.Time `mock:"createTime"`
 }
 
-func TestNewRowsFromStruct(t *testing.T) {
+func TestNewRowsFromInterface(t *testing.T) {
 	m := &MockStruct{
 		Type:       1,
 		Name:       "sqlMock",
@@ -770,7 +770,7 @@ func TestNewRowsFromStruct(t *testing.T) {
 	}
 	excepted := NewRows([]string{"type", "name", "createTime"}).AddRow(m.Type, m.Name, m.CreateTime)
 
-	actual, err := NewRowsFromStruct(m, "mock")
+	actual, err := NewRowsFromInterface(m, "mock")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -782,9 +782,7 @@ func TestNewRowsFromStruct(t *testing.T) {
 	if !same {
 		t.Fatal("reflect value from tag failed")
 	}
-}
 
-func TestNewRowsFromStructs(t *testing.T) {
 	m1 := &MockStruct{
 		Type:       1,
 		Name:       "sqlMock1",
@@ -795,21 +793,21 @@ func TestNewRowsFromStructs(t *testing.T) {
 		Name:       "sqlMock2",
 		CreateTime: time.Now(),
 	}
-	arr := []*MockStruct{m1, m2}
+	arr := [3]*MockStruct{m, m1, m2}
 
-	excepted := NewRows([]string{"type", "name", "createTime"})
+	excepted2 := NewRows([]string{"type", "name", "createTime"})
 	for _, v := range arr {
-		excepted.AddRow(v.Type, v.Name, v.CreateTime)
+		excepted2.AddRow(v.Type, v.Name, v.CreateTime)
 	}
-	actual, err := NewRowsFromStructs("mock", arr[0], arr[1])
+	actual2, err := NewRowsFromInterface(arr, "mock")
 	if err != nil {
 		t.Fatal(err)
 	}
-	same := reflect.DeepEqual(excepted.cols, actual.cols)
+	same = reflect.DeepEqual(excepted2.cols, actual2.cols)
 	if !same {
 		t.Fatal("custom tag reflect failed")
 	}
-	same = reflect.DeepEqual(excepted.rows, actual.rows)
+	same = reflect.DeepEqual(excepted2.rows, actual2.rows)
 	if !same {
 		t.Fatal("reflect value from tag failed")
 	}

From f19b529a490e47daf5768e2e1add08ad18662209 Mon Sep 17 00:00:00 2001
From: Rennbon <343688972@qq.com>
Date: Mon, 13 Dec 2021 15:34:11 +0800
Subject: [PATCH 5/7] refact: rm useless comments

---
 rows.go | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/rows.go b/rows.go
index 00d9310..6425669 100644
--- a/rows.go
+++ b/rows.go
@@ -129,16 +129,9 @@ type Rows struct {
 	closeErr  error
 }
 
-// NewRowsFromStruct new Rows from struct reflect with tagName
-// tagName default "json"
+
 func newRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
-	/*	if m == nil {
-		return nil, errors.New("param m is nil")
-	}*/
 	val := reflect.ValueOf(m).Elem()
-	/*	if val.Kind() != reflect.Struct {
-		return nil, errors.New("param type must be struct")
-	}*/
 	num := val.NumField()
 	if num == 0 {
 		return nil, errors.New("no properties available")
@@ -186,9 +179,6 @@ func NewRowsFromInterface(m interface{}, tagName string) (*Rows, error) {
 	}
 }
 
-// NewRowsFromStructs new Rows from struct slice reflect with tagName
-// NOTE: arr must be of the same type
-// tagName default "json"
 func newRowsFromSliceOrArray(m interface{}, tagName string) (*Rows, error) {
 	vals := reflect.ValueOf(m)
 	if vals.Len() == 0 {
@@ -201,7 +191,6 @@ func newRowsFromSliceOrArray(m interface{}, tagName string) (*Rows, error) {
 	if typ.NumField() == 0 {
 		return nil, errors.New("no properties available")
 	}
-
 	var idx []int
 	tag := "json"
 	if len(tagName) > 0 {

From db273b6de93a85fd049ebe8145de5d59b7b5191a Mon Sep 17 00:00:00 2001
From: Rennbon <343688972@qq.com>
Date: Tue, 15 Feb 2022 19:02:14 +0800
Subject: [PATCH 6/7] fix: replace "expected" to "want"

---
 rows_test.go | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/rows_test.go b/rows_test.go
index 5557396..c0a84f6 100644
--- a/rows_test.go
+++ b/rows_test.go
@@ -768,21 +768,19 @@ func TestNewRowsFromInterface(t *testing.T) {
 		Name:       "sqlMock",
 		CreateTime: time.Now(),
 	}
-	excepted := NewRows([]string{"type", "name", "createTime"}).AddRow(m.Type, m.Name, m.CreateTime)
-
+	want := NewRows([]string{"type", "name", "createTime"}).AddRow(m.Type, m.Name, m.CreateTime)
 	actual, err := NewRowsFromInterface(m, "mock")
 	if err != nil {
 		t.Fatal(err)
 	}
-	same := reflect.DeepEqual(excepted.cols, actual.cols)
+	same := reflect.DeepEqual(want.cols, actual.cols)
 	if !same {
 		t.Fatal("custom tag reflect failed")
 	}
-	same = reflect.DeepEqual(excepted.rows, actual.rows)
+	same = reflect.DeepEqual(want.rows, actual.rows)
 	if !same {
 		t.Fatal("reflect value from tag failed")
 	}
-
 	m1 := &MockStruct{
 		Type:       1,
 		Name:       "sqlMock1",
@@ -794,20 +792,19 @@ func TestNewRowsFromInterface(t *testing.T) {
 		CreateTime: time.Now(),
 	}
 	arr := [3]*MockStruct{m, m1, m2}
-
-	excepted2 := NewRows([]string{"type", "name", "createTime"})
+	want2 := NewRows([]string{"type", "name", "createTime"})
 	for _, v := range arr {
-		excepted2.AddRow(v.Type, v.Name, v.CreateTime)
+		want2.AddRow(v.Type, v.Name, v.CreateTime)
 	}
 	actual2, err := NewRowsFromInterface(arr, "mock")
 	if err != nil {
 		t.Fatal(err)
 	}
-	same = reflect.DeepEqual(excepted2.cols, actual2.cols)
+	same = reflect.DeepEqual(want2.cols, actual2.cols)
 	if !same {
 		t.Fatal("custom tag reflect failed")
 	}
-	same = reflect.DeepEqual(excepted2.rows, actual2.rows)
+	same = reflect.DeepEqual(want2.rows, actual2.rows)
 	if !same {
 		t.Fatal("reflect value from tag failed")
 	}

From 56464bcc02d9efd8bfc82e7da0772594569b0433 Mon Sep 17 00:00:00 2001
From: Rennbon <343688972@qq.com>
Date: Sat, 23 Apr 2022 21:41:58 +0800
Subject: [PATCH 7/7] Add a description

---
 rows.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rows.go b/rows.go
index 6425669..2b51d46 100644
--- a/rows.go
+++ b/rows.go
@@ -129,7 +129,7 @@ type Rows struct {
 	closeErr  error
 }
 
-
+// new Rows and add a set of driver.Value by using the struct reflect tag
 func newRowsFromStruct(m interface{}, tagName ...string) (*Rows, error) {
 	val := reflect.ValueOf(m).Elem()
 	num := val.NumField()
@@ -179,6 +179,7 @@ func NewRowsFromInterface(m interface{}, tagName string) (*Rows, error) {
 	}
 }
 
+// new Rows and add multiple sets of driver.Value by using the tags of the element in reflect type slice/array
 func newRowsFromSliceOrArray(m interface{}, tagName string) (*Rows, error) {
 	vals := reflect.ValueOf(m)
 	if vals.Len() == 0 {