Updated for 32-bit

Author: djthorpe

pkg/sqlite3/conn.go

@@ -3,6 +3,7 @@ package sqlite3
 import (
 	"context"
 	"fmt"
+	"os"
 	"runtime"
 	"sync"
 
@@ -38,6 +39,15 @@ type TxnFunc func(SQTransaction) error
 func OpenPath(path string, flags sqlite3.OpenFlags) (*Conn, error) {
 	poolconn := new(Conn)
 
+	// If no create flag then check to make sure database exists
+	if path != defaultMemory && flags&sqlite3.SQLITE_OPEN_CREATE == 0 {
+		if _, err := os.Stat(path); os.IsNotExist(err) {
+			return nil, ErrNotFound.Withf("%q", path)
+		} else if err != nil {
+			return nil, err
+		}
+	}
+
 	// Open database with flags
 	if conn, err := sqlite3.OpenPathEx(path, flags, ""); err != nil {
 		return nil, err

pkg/sqlite3/pool.go

@@ -27,7 +27,7 @@ import (
 
 // PoolConfig is the starting configuration for a pool
 type PoolConfig struct {
-	Max     int64             `yaml:"max"`       // The maximum number of connections in the pool
+	Max     int32             `yaml:"max"`       // The maximum number of connections in the pool
 	Schemas map[string]string `yaml:"databases"` // Schema names mapped onto path for database file
 	Trace   bool              `yaml:"trace"`     // Profiling for statements
 	Create  bool              `yaml:"create"`    // When false, do not allow creation of new file-based databases
@@ -45,7 +45,7 @@ type Pool struct {
 	errs   chan<- error
 	ctx    context.Context
 	cancel context.CancelFunc
-	n      int64
+	n      int32
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -85,7 +85,7 @@ func OpenPool(config PoolConfig, errs chan<- error) (*Pool, error) {
 	if config.Max == 0 {
 		config.Max = defaultPoolConfig.Max
 	} else {
-		config.Max = maxInt64(config.Max, 1)
+		config.Max = maxInt32(config.Max, 1)
 	}
 
 	// Set default flags if not set
@@ -156,20 +156,20 @@ func (p *Pool) String() string {
 // PUBLIC METHODS
 
 // Max returns the maximum number of connections allowed
-func (p *Pool) Max() int64 {
-	return atomic.LoadInt64(&p.PoolConfig.Max)
+func (p *Pool) Max() int32 {
+	return atomic.LoadInt32(&p.PoolConfig.Max)
 }
 
 // SetMax allowed connections released from pool. Note this does not change
 // the maximum instantly, it will settle to this value over time. Set as value
 // zero to disable opening new connections
-func (p *Pool) SetMax(n int64) {
-	atomic.StoreInt64(&p.PoolConfig.Max, maxInt64(n, 0))
+func (p *Pool) SetMax(n int32) {
+	atomic.StoreInt32(&p.PoolConfig.Max, maxInt32(n, 0))
 }
 
 // Cur returns the current number of used connections
-func (p *Pool) Cur() int64 {
-	return atomic.LoadInt64(&p.n)
+func (p *Pool) Cur() int32 {
+	return atomic.LoadInt32(&p.n)
 }
 
 // Get a connection from the pool, and return it to the pool when the context
@@ -190,7 +190,7 @@ func (p *Pool) Get(ctx context.Context) SQConnection {
 		panic("Expected conn.c to be nil")
 	} else {
 		conn.c = make(chan struct{})
-		atomic.AddInt64(&p.n, 1)
+		atomic.AddInt32(&p.n, 1)
 	}
 
 	// Release the connection in the background
@@ -297,7 +297,7 @@ func (p *Pool) put(conn *Conn) {
 		conn.c = nil
 	}
 	// Choose to put back into pool or close connection
-	n := atomic.AddInt64(&p.n, -1)
+	n := atomic.AddInt32(&p.n, -1)
 	if n >= p.Max() {
 		p.Pool.Put(conn)
 	} else if err := conn.Close(); err != nil {
@@ -371,8 +371,8 @@ func (p *Pool) trace(c *Conn, s *sqlite3.Statement, ns int64) {
 	fmt.Printf("TRACE %q => %v\n", s, time.Duration(ns)*time.Nanosecond)
 }
 
-// maxInt64 returns the maximum of two values
-func maxInt64(a, b int64) int64 {
+// maxInt32 returns the maximum of two values
+func maxInt32(a, b int32) int32 {
 	if a > b {
 		return a
 	}

pkg/sqlite3/schema_test.go

@@ -19,7 +19,7 @@ func Test_Schema_001(t *testing.T) {
 	// Create the pool
 	pool, err := NewPool("", errs)
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 	defer pool.Close()
 
@@ -50,9 +50,10 @@ func Test_Schema_002(t *testing.T) {
 			"main": filepath.Join(tmpdir, "main.sqlite"),
 			"test": filepath.Join(tmpdir, "test.sqlite"),
 		},
+		Create: true,
 	}, errs)
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 	defer pool.Close()
 
@@ -83,9 +84,10 @@ func Test_Schema_003(t *testing.T) {
 			"main": filepath.Join(tmpdir, "main.sqlite"),
 			"test": filepath.Join(tmpdir, "test.sqlite"),
 		},
+		Create: true,
 	}, errs)
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 	defer pool.Close()
 
@@ -146,9 +148,10 @@ func Test_Schema_004(t *testing.T) {
 			"main": filepath.Join(tmpdir, "main.sqlite"),
 			"test": filepath.Join(tmpdir, "test.sqlite"),
 		},
+		Create: true,
 	}, errs)
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 	defer pool.Close()
 
@@ -195,9 +198,10 @@ func Test_Schema_006(t *testing.T) {
 		Schemas: map[string]string{
 			"main": filepath.Join(tmpdir, "main.sqlite"),
 		},
+		Create: true,
 	}, errs)
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 	defer pool.Close()
 
@@ -206,6 +210,7 @@ func Test_Schema_006(t *testing.T) {
 	if conn == nil {
 		t.Fatal("Unexpected nil connection")
 	}
+	defer pool.Put(conn)
 
 	// Create a table
 	if err := conn.Exec(N("table_a").CreateTable(
@@ -245,7 +250,7 @@ func Test_Schema_007(t *testing.T) {
 		Trace: true,
 	}, errs)
 	if err != nil {
-		t.Error(err)
+		t.Fatal(err)
 	}
 	defer pool.Close()
 
@@ -254,6 +259,7 @@ func Test_Schema_007(t *testing.T) {
 	if conn == nil {
 		t.Fatal("Unexpected nil connection")
 	}
+	defer pool.Put(conn)
 
 	// Create a table
 	if err := conn.Exec(N("table_a").CreateTable(

sys/sqlite3/sqliteex_test.go

@@ -97,7 +97,7 @@ func Test_SQLiteEx_002(t *testing.T) {
 	// Run long running query, expect interrupted error
 	if st, err := db.Prepare(longRunningQuery); err != nil {
 		t.Error(err)
-	} else if r, err := st.Exec(0, 9999999999); err != nil && err != sqlite3.SQLITE_INTERRUPT {
+	} else if r, err := st.Exec(0, 99999999); err != nil && err != sqlite3.SQLITE_INTERRUPT {
 		t.Error("Error returned:", err)
 	} else if r != nil {
 		t.Log(r)