When calling scan.Row() it does not autoclose the rows as scan.Rows() does.
Is this intentional? I now end up having to add defer rows.Close() everywhere I used scan.Row()

The &sync.Map{} cache mechanism used in columns.go and values.go caches individual instances of structs, not the "kind" of struct. This causes memory leaks in long-running applications that call scan.Columns or scan.Values on many different struct instances.

// PrintMemUsage outputs the current, total and OS memory being used. As well as the number
// of garage collection cycles completed.
func PrintMemUsage() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	// For info on each, see: https://golang.org/pkg/runtime/#MemStats
	fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
	fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
	fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
	fmt.Printf("\tNumGC = %v\n", m.NumGC)
}
func bToMb(b uint64) uint64 {
	return b / 1024 / 1024
}

type MyObject struct {
	Value string "db:value"
}

func TestMemoryLeak(t *testing.T) {
	PrintMemUsage()
	for i := 0; i < 1e6; i++ {
		obj := &MyObject{Value: "Some value goes here"}
		cols, err := scan.ColumnsStrict(obj)
		if err != nil {
			t.Fail()
		}
		_, err = scan.Values(cols, obj)
		if err != nil {
			t.Fail()
		}
	}
	runtime.GC()
	PrintMemUsage()
}

outputs

=== RUN   TestMemoryLeak
Alloc = 4 MiB	TotalAlloc = 7 MiB	Sys = 18 MiB	NumGC = 3
Alloc = 503 MiB	TotalAlloc = 724 MiB	Sys = 619 MiB	NumGC = 13
--- PASS: TestMemoryLeak (2.45s)
PASS

Additionally, the debugger shows the columns cache map contains 100k objects.

Suggest either

• changing the cache key to something that is consistent across different instances of the same struct
• removing the cache mechanism entirely (we aren't even hitting the cache unless scan.Columns is called on the same instance multiple times)

Essentially #16, but for scan.Columns and scan.Values

Today it is impossible to list all columns for nested structs.

type thingy struct {
	ColA int `db:"a"`
}
type thingyWrapper struct {
	thingy
	ColB string `db:"b"`
}

func TestEmbeddedBehavior(t *testing.T) {
	thing := &thingy{}
	cols1, err := scan.Columns(thing)
	assert.NoError(t, err)
	assert.Equal(t, []string{"a"}, cols1)

	thingWrapper := &thingyWrapper{}
	cols2, err := scan.Columns(thingWrapper)
	assert.NoError(t, err)
	assert.Equal(t, []string{"a", "b"}, cols2)
}

fails with

Expected :[]string{"a", "b"}
Actual   :[]string{"b"}

Awesome library. Is there any support for JSON fields and the ability to extract those into a struct?

sq.Insert(userCols...).
Into("users").
Values(scan.Values(userCols, &user)...).RunWith(db).Exec()
err converting argument $1 type: unsupported type []interface {}, a slice of interface
scan.Values(userCols, &user) return a slice of interface,but args ...interface{} is a arry interface.

Dependabot couldn't find a Gopkg.toml for this project.

Dependabot requires a Gopkg.toml to evaluate your project's current Go dependencies. It had expected to find one at the path: /Gopkg.toml.

If this isn't a Go project, or if it is a library, you may wish to disable updates for it from within Dependabot.

You can mention @dependabot in the comments below to contact the Dependabot team.

Hi, I`m trying to update to version 2.0.0, but go get -u points always do 1.3.0

What I`m doing wrong?

Thanks :D

scan.Columns does not take into account the excluded columns when checking values from the cache.
This means that if it is called on the same struct with different exclusion conditions, the first set of columns is returned for all additional calls.

type thingy struct {
	StrCol string `db:"str_col"`
	IntCol int    `db:"int_col"`
}

func TestExcludedBehavior(t *testing.T) {
	thing := &thingy{}
	cols1, err := scan.Columns(thing)
	assert.NoError(t, err)
	assert.Equal(t, []string{"str_col", "int_col"}, cols1)
	cols2, err := scan.Columns(thing, "int_col")
	assert.NoError(t, err)
	assert.Equal(t, []string{"str_col"}, cols2)
}

=== RUN   TestExcludedBehavior
    sql_test.go:21: 
        	Error Trace:	sql_test.go:21
        	Error:      	Not equal: 
        	            	expected: []string{"str_col"}
        	            	actual  : []string{"str_col", "int_col"}
        	            	
        	            	Diff:
        	            	--- Expected
        	            	+++ Actual
        	            	@@ -1,3 +1,4 @@
        	            	-([]string) (len=1) {
        	            	- (string) (len=7) "str_col"
        	            	+([]string) (len=2) {
        	            	+ (string) (len=7) "str_col",
        	            	+ (string) (len=7) "int_col"
        	            	 }
        	Test:       	TestExcludedBehavior
--- FAIL: TestExcludedBehavior (0.00s)


Expected :[]string{"str_col"}
Actual   :[]string{"str_col", "int_col"}
<Click to see difference>


FAIL

Process finished with the exit code 1

Suggest changing the cache key to be a struct { value reflect.Value, cols string } where cols is strings.Join(expected, " ").
I can open up a PR later this week.

rows, _ := db.Query("SELECT * FROM persons where name = 'brett' LIMIT 1")
var person Person
// if rows.Count==0
err := scan.Row(&person, rows)
// err:sql: no rows in result set

type Struct1 struct {
Name1 string db:"nam_e1" // no val
Name2 string db:"name2" // has val
}
type Struct2 struct {
Struct1
Name3 string db:"nam_e3" // has val
Name4 string db:"name4" // has val
}
func main(){
sql="select nam_e1,name2,nam_e3,name4"
rows, err := conn.Query(sql)
var st2 []Struct2
err = scan.Rows(&st2 , rows)
// Name1 string db:"nam_e1" // no value
// st2.nam_e1 no value
}