Updated sqlite

Author: djthorpe

etc/server.yaml

@@ -24,13 +24,14 @@ sqlite3:
     main: ":memory:"
     test: /tmp/test.sqlite  
 
-  # Set create to true to allow databases which don't exist to be created.
-  create: true
+  # Set create to true to allow databases which don't exist to be created, or
+  # else error will be reported on server start. In-memory databases can always
+  # be created.
+  create: false
 
   # Set trace to true to enable the ability to profile queries. Profiling information
   # can be displayed through the API.
   trace: true
 
   # Set max number of connections that can be simultaneously opened
-  max: 100
-
+  max: 50

pkg/sqlite3/pool.go

@@ -58,7 +58,7 @@ var (
 		Trace:   false,
 		Create:  true,
 		Schemas: map[string]string{defaultSchema: defaultMemory},
-		Flags:   sqlite3.DefaultFlags | sqlite3.SQLITE_OPEN_SHAREDCACHE,
+		Flags:   sqlite3.SQLITE_OPEN_CREATE | sqlite3.SQLITE_OPEN_SHAREDCACHE,
 	}
 )
 
@@ -142,6 +142,7 @@ func (p *Pool) Close() error {
 
 func (p *Pool) String() string {
 	str := "<pool"
+	str += fmt.Sprintf(" ver=%q", Version())
 	str += fmt.Sprint(" cur=", p.Cur())
 	str += fmt.Sprint(" max=", p.Max())
 	str += fmt.Sprint(" flags=", p.Flags)
@@ -234,7 +235,7 @@ func (p *Pool) new() (*Conn, error) {
 	// Always allow memory databases to be created
 	flags := p.Flags
 	if defaultPath == defaultMemory {
-		flags |= sqlite3.SQLITE_OPEN_MEMORY | sqlite3.SQLITE_OPEN_CREATE
+		flags |= sqlite3.SQLITE_OPEN_CREATE
 	}
 
 	// Perform the open
@@ -243,6 +244,14 @@ func (p *Pool) new() (*Conn, error) {
 		return nil, err
 	}
 
+	// Set trace
+	if p.PoolConfig.Trace {
+		conn.SetTraceHook(func(_ sqlite3.TraceType, a, b unsafe.Pointer) int {
+			p.trace(conn, (*sqlite3.Statement)(a), *(*int64)(b))
+			return 0
+		}, sqlite3.SQLITE_TRACE_PROFILE)
+	}
+
 	// Attach additional databases
 	var result error
 	for schema := range p.Schemas {
@@ -258,14 +267,6 @@ func (p *Pool) new() (*Conn, error) {
 		}
 	}
 
-	// Set trace
-	if p.PoolConfig.Trace {
-		conn.SetTraceHook(func(_ sqlite3.TraceType, a, b unsafe.Pointer) int {
-			p.trace(conn, (*sqlite3.Statement)(a), *(*int64)(b))
-			return 0
-		}, sqlite3.SQLITE_TRACE_PROFILE)
-	}
-
 	// Set auth
 	if p.PoolConfig.Auth != nil {
 		conn.SetAuthorizerHook(func(action sqlite3.SQAction, args [4]string) sqlite3.SQAuth {
@@ -328,14 +329,6 @@ func (p *Pool) err(err error) {
 	}
 }
 
-// maxInt64 returns the maximum of two values
-func maxInt64(a, b int64) int64 {
-	if a > b {
-		return a
-	}
-	return b
-}
-
 // Attach database as schema. If path is empty then a new in-memory database
 // is attached.
 func (p *Pool) attach(conn *Conn, schema, path string) error {
@@ -348,29 +341,18 @@ func (p *Pool) attach(conn *Conn, schema, path string) error {
 	// Create a new database or return an error if it doesn't exist
 	if path != defaultMemory {
 		if _, err := os.Stat(path); os.IsNotExist(err) {
-			if err := p.attachcreate(path); err != nil {
+			if err := p.attachCreate(path); err != nil {
 				return err
 			}
 		} else if err != nil {
 			return err
 		}
 	}
-	fmt.Println(Q("ATTACH DATABASE ", Quote(path), " AS ", QuoteIdentifier(schema)))
 	return conn.Exec(Q("ATTACH DATABASE ", Quote(path), " AS ", QuoteIdentifier(schema)), nil)
 }
 
-// Detach named database as schema
-func (p *Pool) detach(conn *Conn, schema string) error {
-	return conn.Exec(Q("DETACH DATABASE ", QuoteIdentifier(schema)), nil)
-}
-
-// Trace
-func (p *Pool) trace(c *Conn, s *sqlite3.Statement, ns int64) {
-	fmt.Printf("TRACE %q => %v\n", s, time.Duration(ns)*time.Nanosecond)
-}
-
 // Create a database before attaching
-func (p *Pool) attachcreate(path string) error {
+func (p *Pool) attachCreate(path string) error {
 	if p.PoolConfig.Flags&sqlite3.SQLITE_OPEN_CREATE == 0 {
 		return ErrBadParameter.Withf("Database does not exist: %q", path)
 	}
@@ -383,3 +365,16 @@ func (p *Pool) attachcreate(path string) error {
 		return nil
 	}
 }
+
+// Trace
+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 {
+	if a > b {
+		return a
+	}
+	return b
+}

plugin/sqlite3/handlers.go

@@ -149,16 +149,14 @@ func (p *plugin) ServeSchema(w http.ResponseWriter, req *http.Request) {
 		Filename: conn.Filename(params[0]),
 	}
 
-	if err := conn.(*sqlite3.Conn).Exec(Q("PRAGMA database_list"), func(row, col []string) bool {
+	if err := conn.(*sqlite3.Conn).Exec(Q("PRAGMA database_list;"), func(row, col []string) bool {
 		fmt.Printf("%q => %q\n", col, row)
 		return false
 	}); err != nil {
 		router.ServeError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	fmt.Printf("%v => %q\n", params[0], conn.Filename(params[0]))
-
 	// Set memory flag
 	if response.Filename == "" {
 		response.Memory = true

sys/sqlite3/conn.go

@@ -18,6 +18,7 @@ import "C"
 
 import (
 	"fmt"
+	"strings"
 	"unsafe"
 
 	// Modules
@@ -37,6 +38,7 @@ type Conn C.sqlite3
 // GLOBALS
 
 const (
+	SQLITE_OPEN_NONE         OpenFlags = 0
 	SQLITE_OPEN_READONLY     OpenFlags = C.SQLITE_OPEN_READONLY                         // The database is opened in read-only mode. If the database does not already exist, an error is returned.
 	SQLITE_OPEN_READWRITE    OpenFlags = C.SQLITE_OPEN_READWRITE                        // The database is opened for reading and writing if possible, or reading only if the file is write protected by the operating system. In either case the database must already exist, otherwise an error is returned.
 	SQLITE_OPEN_CREATE       OpenFlags = C.SQLITE_OPEN_CREATE | C.SQLITE_OPEN_READWRITE // The database is created if it does not already exist
@@ -46,7 +48,9 @@ const (
 	SQLITE_OPEN_FULLMUTEX    OpenFlags = C.SQLITE_OPEN_FULLMUTEX                        // The new database connection will use the "serialized" threading mode. This means the multiple threads can safely attempt to use the same database connection at the same time. (Mutexes will block any actual concurrency, but in this mode there is no harm in trying.)
 	SQLITE_OPEN_SHAREDCACHE  OpenFlags = C.SQLITE_OPEN_SHAREDCACHE                      // The database is opened shared cache enabled, overriding the default shared cache setting provided by sqlite3_enable_shared_cache().
 	SQLITE_OPEN_PRIVATECACHE OpenFlags = C.SQLITE_OPEN_PRIVATECACHE                     // The database is opened shared cache disabled, overriding the default shared cache setting provided by sqlite3_enable_shared_cache().
-//	SQLITE_OPEN_NOFOLLOW     OpenFlags = C.SQLITE_OPEN_NOFOLLOW                         // The database filename is not allowed to be a symbolic link
+	SQLITE_OPEN_NOFOLLOW     OpenFlags = C.SQLITE_OPEN_NOFOLLOW                         // The database filename is not allowed to be a symbolic link
+	SQLITE_OPEN_MIN                    = SQLITE_OPEN_READONLY
+	SQLITE_OPEN_MAX                    = SQLITE_OPEN_NOFOLLOW
 )
 
 const (
@@ -84,6 +88,46 @@ func (c *Conn) String() string {
 	return str + ">"
 }
 
+func (v OpenFlags) StringFlag() string {
+	switch v {
+	case SQLITE_OPEN_NONE:
+		return "SQLITE_OPEN_NONE"
+	case SQLITE_OPEN_READONLY:
+		return "SQLITE_OPEN_READONLY"
+	case SQLITE_OPEN_READWRITE:
+		return "SQLITE_OPEN_READWRITE"
+	case SQLITE_OPEN_CREATE:
+		return "SQLITE_OPEN_CREATE"
+	case SQLITE_OPEN_URI:
+		return "SQLITE_OPEN_URI"
+	case SQLITE_OPEN_MEMORY:
+		return "SQLITE_OPEN_MEMORY"
+	case SQLITE_OPEN_NOMUTEX:
+		return "SQLITE_OPEN_NOMUTEX"
+	case SQLITE_OPEN_FULLMUTEX:
+		return "SQLITE_OPEN_FULLMUTEX"
+	case SQLITE_OPEN_SHAREDCACHE:
+		return "SQLITE_OPEN_SHAREDCACHE"
+	case SQLITE_OPEN_PRIVATECACHE:
+		return "SQLITE_OPEN_PRIVATECACHE"
+	default:
+		return "[?? Invalid OpenFlags value]"
+	}
+}
+
+func (v OpenFlags) String() string {
+	if v == SQLITE_OPEN_NONE {
+		return v.StringFlag()
+	}
+	str := ""
+	for f := SQLITE_OPEN_MIN; f <= SQLITE_OPEN_MAX; f <<= 1 {
+		if v&f != 0 {
+			str += "|" + f.StringFlag()
+		}
+	}
+	return strings.TrimPrefix(str, "|")
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // METHODS