panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x40da61f]

goroutine 10962 [running]:
database/sql.(*Rows).close(0xc421780600, 0x44ae840, 0x44e9200, 0x0, 0x0)
	/usr/local/Cellar/go/1.8.1/libexec/src/database/sql/sql.go:2445 +0x15f
database/sql.(*Rows).awaitDone(0xc421780600, 0x44b1240, 0xc421e19040)
	/usr/local/Cellar/go/1.8.1/libexec/src/database/sql/sql.go:2122 +0x8e
created by database/sql.(*Rows).initContextClose
	/usr/local/Cellar/go/1.8.1/libexec/src/database/sql/sql.go:2116 +0x92
exit status 2

package main

import (
	"context"
	"database/sql"
	_ "github.com/lib/pq"
	_ "github.com/mattn/go-sqlite3"
	"log"
	"math/rand"
	"runtime"
	"sync"
	"time"
)

const (
	// DRIVER = "postgres"
	// DB     = "postgres://postgres:postgres@127.0.0.1:5432/postgres?sslmode=disable"
	DRIVER = "sqlite3"
	DB     = "file::memory:?mode=memory&cache=shared"
)

var (
	db      *sql.DB
	stmtMap map[string]*sql.Stmt
	mu      *sync.RWMutex
	jobs    chan struct{}
)

func prepare(ctx context.Context, query string) (*sql.Stmt, error) {
	mu.RLock()
	stmt, ok := stmtMap[query]
	mu.RUnlock()
	if ok {
		return stmt, nil
	}
	stmt, err := db.PrepareContext(ctx, query)
	if err != nil {
		return nil, err
	}
	mu.Lock()
	stmtMap[query] = stmt
	mu.Unlock()
	return stmt, nil
}

func queryStmt(ctx context.Context) error {
	stmt, err := prepare(ctx, "SELECT 1;")
	if err != nil {
		return err
	}
	rows, err := stmt.QueryContext(ctx)
	if err != nil {
		return err
	}
	rows.Close()
	return nil
}

func queryShortStmt(ctx context.Context) error {
	stmt, err := db.PrepareContext(ctx, "SELECT 1;")
	if err != nil {
		return err
	}
	rows, err := stmt.QueryContext(ctx)
	if err != nil {
		return err
	}
	rows.Close()
	stmt.Close()
	return nil
}

func queryRowStmt(ctx context.Context) error {
	stmt, err := prepare(ctx, "SELECT 1;")
	if err != nil {
		return err
	}
	var v int
	err = stmt.QueryRowContext(ctx).Scan(&v)
	if err != nil {
		return err
	}
	return nil
}

func query(ctx context.Context) error {
	rows, err := db.QueryContext(ctx, "SELECT 1;")
	if err != nil {
		return err
	}
	rows.Close()
	return nil
}

func handler(num int) {
	timeout := time.Duration(rand.Intn(100)) * time.Millisecond
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()
	queryStmt(ctx) // <-- segfaults almost immediately
	// queryRowStmt(ctx) // <-- segfaults eventually, just be patient
	// queryShortStmt(ctx) // <-- segfaults eventually, just be patient
	// query(ctx) // <-- this one seems to behave correct
}

func main() {
	jobs = make(chan struct{}, 100)
	stmtMap = make(map[string]*sql.Stmt)
	mu = new(sync.RWMutex)
	rand.Seed(1)
	runtime.GOMAXPROCS(4)

	var err error
	db, err = sql.Open(DRIVER, DB)
	if err != nil {
		log.Fatalln(err)
	}
	db.SetMaxIdleConns(20)
	db.SetMaxOpenConns(20)

	// dispatcher
	var i int
	go func() {
		for {
			select {
			case <-jobs:
				i++
				go handler(i)
			}
		}
	}()

	// keep the job queue filled
	for {
		jobs <- struct{}{}
	}
}

if rs.releaseConn == nil {
	fmt.Printf("NIL Rows.releaseConn() row %+v with driver conn %+v\n", rs, rs.dc)
}

NIL Rows.releaseConn() row &{
	dc:0xc4201be380 
	releaseConn:<nil> 
	rowsi:0xc42005b420 
	cancel:0x10ab2c0 
	closeStmt:<nil> 
	closemu:{
		w:{
			state:1 
			sema:0
		} 
		writerSem:0 
		readerSem:0 
		readerCount:-1073741824 
		readerWait:0
	} 
	closed:true 
	lasterr:{} 
	lastcols:[]
} 

with driver conn &{
	db:0xc4200940a0 
	createdAt:{
		sec:63628968112 
		nsec:642549333 
		loc:0x1324dc0
	} 
	Mutex:{state:0 sema:0} 
	ci:0xc420092f00 
	closed:false 
	finalClosed:false 
	openStmt:map[0xc420394b80:true 0xc420146a40:true 0xc42146a240:true 0xc4216b9280:true 0xc420f7ac40:true 0xc42084f640:true 0xc4214acf40:true 0xc421570b40:true 0xc42110bac0:true 0xc4211ceb00:true 0xc42017f000:true 0xc4216b8c00:true 0xc4200c8300:true 0xc420f8e000:true 0xc42110adc0:true 0xc421571c80:true] 
	inUse:true 
	onPut:[] 
	dbmuClosed:false
}