FilesExpand file tree

 v1.3.0

/

scanner.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

170 lines (141 loc) · 4.23 KB

 v1.3.0

/

scanner.go

Copy path

Top

File metadata and controls

• Code
• Blame

170 lines (141 loc) · 4.23 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

package scan

import (

"database/sql"

"errors"

"fmt"

"io"

"log"

"reflect"

"strings"

)

var (

// ErrTooManyColumns indicates that a select query returned multiple columns and

// attempted to bind to a slice of a primitive type. For example, trying to bind

// `select col1, col2 from mutable` to []string

ErrTooManyColumns = errors.New("too many columns returned for primitive slice")

// ErrSliceForRow occurs when trying to use Row on a slice

ErrSliceForRow = errors.New("cannot scan Row into slice")

// AutoClose is true when scan should automatically close Scanner when the scan

// is complete. If you set it to false, then you must defer rows.Close() manually

AutoClose = true

)

// Row scans a single row into a single variable. It requires that you use

// db.Query and not db.QueryRow, because QueryRow does not return column names.

// There is no performance impact in using one over the other. QueryRow only

// defers returning err until Scan is called, which is an unnecessary

// optimization for this library.

func Row(v interface{}, r RowsScanner) error {

return row(v, r, false)

}

// RowStrict scans a single row into a single variable. It is identical to

// Row, but it ignores fields that do not have a db tag

func RowStrict(v interface{}, r RowsScanner) error {

return row(v, r, true)

}

func row(v interface{}, r RowsScanner, strict bool) error {

vType := reflect.TypeOf(v)

if k := vType.Kind(); k != reflect.Ptr {

return fmt.Errorf("%q must be a pointer", k.String())

}

vType = vType.Elem()

vVal := reflect.ValueOf(v).Elem()

if vType.Kind() == reflect.Slice {

return ErrSliceForRow

}

sl := reflect.New(reflect.SliceOf(vType))

err := rows(sl.Interface(), r, strict)

if err != nil {

return err

}

sl = sl.Elem()

if sl.Len() == 0 {

return sql.ErrNoRows

}

vVal.Set(sl.Index(0))

return nil

}

// Rows scans sql rows into a slice (v)

func Rows(v interface{}, r RowsScanner) (outerr error) {

return rows(v, r, false)

}

// RowsStrict scans sql rows into a slice (v) only using db tags

func RowsStrict(v interface{}, r RowsScanner) (outerr error) {

return rows(v, r, true)

}

func rows(v interface{}, r RowsScanner, strict bool) (outerr error) {

if AutoClose {

defer closeRows(r)

}

vType := reflect.TypeOf(v)

if k := vType.Kind(); k != reflect.Ptr {

return fmt.Errorf("%q must be a pointer", k.String())

}

sliceType := vType.Elem()

if reflect.Slice != sliceType.Kind() {

return fmt.Errorf("%q must be a slice", sliceType.String())

}

sliceVal := reflect.Indirect(reflect.ValueOf(v))

itemType := sliceType.Elem()

cols, err := r.Columns()

if err != nil {

return err

}

isPrimitive := itemType.Kind() != reflect.Struct

for r.Next() {

sliceItem := reflect.New(itemType).Elem()

var pointers []interface{}

if isPrimitive {

if len(cols) > 1 {

return ErrTooManyColumns

}

pointers = []interface{}{sliceItem.Addr().Interface()}

} else {

pointers = structPointers(sliceItem, cols, strict)

}

if len(pointers) == 0 {

return nil

}

err := r.Scan(pointers...)

if err != nil {

return err

}

sliceVal.Set(reflect.Append(sliceVal, sliceItem))

}

return r.Err()

}

// fieldByName gets a struct's field by first looking up the db struct tag and falling

// back to the field's name in Title case.

func fieldByName(v reflect.Value, name string, strict bool) reflect.Value {

typ := v.Type()

for i := 0; i < v.NumField(); i++ {

tag, ok := typ.Field(i).Tag.Lookup("db")

if ok && tag == name {

return v.Field(i)

}

}

if strict {

return reflect.ValueOf(nil)

}

return v.FieldByName(strings.Title(name))

}

func structPointers(stct reflect.Value, cols []string, strict bool) []interface{} {

pointers := make([]interface{}, 0, len(cols))

for _, colName := range cols {

fieldVal := fieldByName(stct, colName, strict)

if !fieldVal.IsValid() || !fieldVal.CanSet() {

// have to add if we found a column because Scan() requires

// len(cols) arguments or it will error. This way we can scan to

// a useless pointer

var nothing interface{}

pointers = append(pointers, &nothing)

continue

}

pointers = append(pointers, fieldVal.Addr().Interface())

}

return pointers

}

func closeRows(c io.Closer) {

if err := c.Close(); err != nil {

log.Printf("failed to close rows: %+v\n", err)

}

}