Updated blob so that a copy is made

Author: djthorpe

Makefile

@@ -37,7 +37,7 @@ plugins: $(PLUGIN_DIR)
 npm: $(NPM_DIR)
 
 cmd: dependencies mkdir $(CMD_DIR)
-  
+
 $(NPM_DIR): FORCE
 	@echo Build npm $(notdir $@)
 	@cd $@ && ${NPM} run build

pkg/sqlite3/cache.go

@@ -42,10 +42,10 @@ func (cache *ConnCache) Prepare(conn *sqlite3.ConnEx, q string) (*Results, error
 	}
 	st := cache.load(q)
 	if st == nil {
-		// Prepare a statement and store in cache
-		var err error
 		cache.Mutex.Lock()
 		defer cache.Mutex.Unlock()
+		// Prepare a statement and store in cache
+		var err error
 		if st, err = conn.Prepare(q); err != nil {
 			return nil, err
 		} else {
@@ -57,6 +57,9 @@ func (cache *ConnCache) Prepare(conn *sqlite3.ConnEx, q string) (*Results, error
 
 // Close all conn cache prepared statements
 func (cache *ConnCache) Close() error {
+	cache.Mutex.Lock()
+	defer cache.Mutex.Unlock()
+
 	var result error
 	cache.Map.Range(func(key, value interface{}) bool {
 		if err := value.(*sqlite3.StatementEx).Close(); err != nil {

pkg/sqlite3/cache_test.go

@@ -29,7 +29,7 @@ func Test_Cache_001(t *testing.T) {
 		// SELECT n between 0-9 over 100 executions in parallel should
 		// return the same result, with a perfect cache hit rate of 9 in 10?
 		var wg sync.WaitGroup
-		for i := 0; i < 20; i++ {
+		for i := 0; i < 1000; i++ {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()

pkg/sqlite3/pool_test.go

@@ -33,15 +33,15 @@ func Test_Pool_002(t *testing.T) {
 	} else {
 		t.Log(pool)
 	}
-	pool.SetMax(1000)
+	pool.SetMax(5000)
 
 	// Get/put connections
 	var wg sync.WaitGroup
-	for i := 0; i < 1000; i++ {
+	for i := 0; i < 5000; i++ {
 		wg.Add(1)
 		go func(i int) {
 			defer wg.Done()
-			<-time.After(randomDuration(100 * time.Millisecond))
+			<-time.After(randomDuration(10 * time.Millisecond))
 			conn := pool.Get()
 			if conn != nil {
 				t.Log("conn [", i, "] => ", conn, " cur=", pool.Cur())
@@ -50,7 +50,7 @@ func Test_Pool_002(t *testing.T) {
 					return err
 				})
 				// Wait for a random amount of time before we open the next connection
-				<-time.After(randomDuration(100 * time.Millisecond))
+				<-time.After(randomDuration(10 * time.Millisecond))
 				// Return connection
 				pool.Put(conn)
 				t.Log("  returned conn [", i, "] => cur=", pool.Cur())

sys/sqlite3/column.go

@@ -86,16 +86,13 @@ func (s *Statement) ColumnText(index int) string {
 	}
 }
 
-// Return blob
-func (s *Statement) ColumnBlob(index int) []byte {
-	// TODO: This might make many copies of the data? Look into this
-
-	// Allocate a blob
+// Return blob, copy data if clone is true
+func (s *Statement) ColumnBlob(index int, clone bool) []byte {
+	// Got blob contents
 	p := C.sqlite3_column_blob((*C.sqlite3_stmt)(s), C.int(index))
 	if p == nil {
 		return nil
 	}
-
 	// Get length of blob
 	len := s.ColumnBytes(index)
 	if len == 0 {
@@ -109,7 +106,13 @@ func (s *Statement) ColumnBlob(index int) []byte {
 	data.Cap = len
 
 	// Return slice
-	return *(*[]byte)(unsafe.Pointer(&data))
+	if clone {
+		dst := make([]byte, len)
+		copy(dst, *(*[]byte)(unsafe.Pointer(&data)))
+		return dst
+	} else {
+		return *(*[]byte)(unsafe.Pointer(&data))
+	}
 }
 
 // Return column as interface
@@ -125,7 +128,7 @@ func (s *Statement) ColumnInterface(index int) interface{} {
 	case SQLITE_NULL:
 		return nil
 	case SQLITE_BLOB:
-		return s.ColumnBlob(index)
+		return s.ColumnBlob(index, true)
 	}
 	panic(fmt.Sprint("Bad type returned for column:", t))
 }

sys/sqlite3/results.go

@@ -100,11 +100,7 @@ func (r *Results) Next(t ...reflect.Type) ([]interface{}, error) {
 				r.cols[i] = v
 			}
 		} else {
-			if v, err := r.value(i); err != nil {
-				result = multierror.Append(result, err)
-			} else {
-				r.cols[i] = v
-			}
+			r.cols[i] = r.value(i)
 		}
 	}
 
@@ -188,21 +184,8 @@ func (r *Results) ColumnOriginName(i int) string {
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
-func (r *Results) value(index int) (interface{}, error) {
-	switch r.st.ColumnType(index) {
-	case SQLITE_INTEGER:
-		return r.st.ColumnInt64(index), nil
-	case SQLITE_FLOAT:
-		return r.st.ColumnDouble(index), nil
-	case SQLITE_TEXT:
-		return r.st.ColumnText(index), nil
-	case SQLITE_BLOB:
-		return r.st.ColumnBlob(index), nil
-	case SQLITE_NULL:
-		return nil, nil
-	default:
-		return nil, fmt.Errorf("Unsupported column type %d", r.st.ColumnType(index))
-	}
+func (r *Results) value(index int) interface{} {
+	return r.st.ColumnInterface(index)
 }
 
 func (r *Results) castvalue(index int, t reflect.Type) (interface{}, error) {
@@ -251,7 +234,7 @@ func (r *Results) castvalue(index int, t reflect.Type) (interface{}, error) {
 		}
 	case typeBlob:
 		if st == SQLITE_BLOB {
-			return r.st.ColumnBlob(index), nil
+			return r.st.ColumnBlob(index, true), nil
 		} else if st == SQLITE_TEXT {
 			return []byte(r.st.ColumnText(index)), nil
 		}