Updated bugs

Author: djthorpe

etc/server.yaml

@@ -21,13 +21,13 @@ handlers:
 sqlite3:
   # Databases to load and/or create. Only the 'main' database is required.
   databases:
-    main: ":memory:"
-    test: /tmp/test.sqlite  
-    
+    main: /tmp/test.sqlite 
+    test: ":memory:"
+
   # 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
+  create: true
 
   # Set trace to true to enable the ability to profile queries. Profiling information
   # can be displayed through the API.

pkg/sqlite3/pool.go

@@ -58,7 +58,7 @@ var (
 		Trace:   false,
 		Create:  true,
 		Schemas: map[string]string{defaultSchema: defaultMemory},
-		Flags:   sqlite3.SQLITE_OPEN_CREATE | sqlite3.SQLITE_OPEN_SHAREDCACHE,
+		Flags:   sqlite3.SQLITE_OPEN_CREATE | sqlite3.SQLITE_OPEN_READWRITE | sqlite3.SQLITE_OPEN_SHAREDCACHE,
 	}
 )
 
@@ -257,7 +257,7 @@ func (p *Pool) new() (*Conn, error) {
 	for schema := range p.Schemas {
 		schema = strings.TrimSpace(schema)
 		path := p.pathForSchema(schema)
-		if path == defaultPath {
+		if schema == defaultSchema {
 			continue
 		}
 		if path == "" {

pkg/sqlite3/schema.go

@@ -1,7 +1,6 @@
 package sqlite3
 
 import (
-	"fmt"
 
 	// Namespace imports
 	. "github.com/djthorpe/go-sqlite"
@@ -13,7 +12,7 @@ import (
 
 // Schemas returns a list of schemas
 func (c *Conn) Schemas() []string {
-	var schemas []string
+	schemas := []string{}
 	if err := c.Exec(Q("PRAGMA database_list"), func(row, col []string) bool {
 		schemas = append(schemas, row[1])
 		return false
@@ -44,7 +43,7 @@ func (c *Conn) ColumnsForTable(schema, table string) []SQColumn {
 	if schema == "" {
 		return c.ColumnsForTable(defaultSchema, table)
 	}
-	var result []SQColumn
+	result := []SQColumn{}
 	if err := c.Exec(Q("PRAGMA ", N(schema), ".table_info(", N(table), ")"), func(row, k []string) bool {
 		// k is "cid" "name" "type" "notnull" "dflt_value" "pk"
 		col := C(row[1]).WithType(row[2])
@@ -58,7 +57,6 @@ func (c *Conn) ColumnsForTable(schema, table string) []SQColumn {
 		result = append(result, col)
 		return false
 	}); err != nil {
-		fmt.Println(err)
 		return nil
 	}
 	return result
@@ -70,7 +68,7 @@ func (c *Conn) ColumnsForIndex(schema, index string) []string {
 		return c.ColumnsForIndex(defaultSchema, index)
 	}
 
-	var result []string
+	result := []string{}
 	if err := c.Exec(Q("PRAGMA ", N(schema), ".index_info(", N(index), ")"), func(row, c []string) bool {
 		result = append(result, row[2])
 		return false
@@ -87,7 +85,7 @@ func (c *Conn) IndexesForTable(schema, table string) []SQIndexView {
 	} else if schema == "" {
 		return c.IndexesForTable(defaultSchema, table)
 	}
-	var result []SQIndexView
+	result := []SQIndexView{}
 	if err := c.ExecEx(Q("PRAGMA ", N(schema), ".index_list(", N(table), ")").Query(), func(row, _ []string) bool {
 		// columns are is "seq" "name" "unique" "origin" "partial"
 
@@ -128,7 +126,7 @@ func (c *Conn) Views(schema string) []string {
 // provided, then only modules with those name prefixes are returned.
 func (c *Conn) Modules(prefix ...string) []string {
 	// Get the names, return
-	var result []string
+	result := []string{}
 	if err := c.Exec(Q("PRAGMA module_list"), func(row, _ []string) bool {
 		if module := row[0]; len(prefix) == 0 || inList(prefix, module, true) {
 			result = append(result, module)

plugin/sqlite3/handlers.go

@@ -38,9 +38,16 @@ type PoolResponse struct {
 }
 
 type SchemaResponse struct {
-	Schema   string `json:"schema"`
-	Filename string `json:"filename,omitempty"`
-	Memory   bool   `json:"memory,omitempty"`
+	Schema   string                `json:"schema"`
+	Filename string                `json:"filename,omitempty"`
+	Memory   bool                  `json:"memory,omitempty"`
+	Tables   []SchemaTableResponse `json:"tables,omitempty"`
+}
+
+type SchemaTableResponse struct {
+	Name    string   `json:"name"`
+	Schema  string   `json:"schema"`
+	Indexes []string `json:"indexes,omitempty"`
 }
 
 type SqlRequest struct {
@@ -147,6 +154,7 @@ func (p *plugin) ServeSchema(w http.ResponseWriter, req *http.Request) {
 	response := SchemaResponse{
 		Schema:   params[0],
 		Filename: conn.Filename(params[0]),
+		Tables:   []SchemaTableResponse{},
 	}
 
 	if err := conn.(*sqlite3.Conn).Exec(Q("PRAGMA database_list;"), func(row, col []string) bool {
@@ -162,6 +170,14 @@ func (p *plugin) ServeSchema(w http.ResponseWriter, req *http.Request) {
 		response.Memory = true
 	}
 
+	// Populate tables
+	for _, table := range conn.Tables(params[0]) {
+		response.Tables = append(response.Tables, SchemaTableResponse{
+			Name:   table,
+			Schema: params[0],
+		})
+	}
+
 	// Serve response
 	router.ServeJSON(w, response, http.StatusOK, 2)
 }

sys/sqlite3/conn.go

@@ -39,15 +39,15 @@ type Conn C.sqlite3
 
 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
-	SQLITE_OPEN_URI          OpenFlags = C.SQLITE_OPEN_URI                              // The filename can be interpreted as a URI if this flag is set.
-	SQLITE_OPEN_MEMORY       OpenFlags = C.SQLITE_OPEN_MEMORY                           // The database will be opened as an in-memory database. The database is named by the "filename" argument for the purposes of cache-sharing, if shared cache mode is enabled, but the "filename" is otherwise ignored.
-	SQLITE_OPEN_NOMUTEX      OpenFlags = C.SQLITE_OPEN_NOMUTEX                          // The new database connection will use the "multi-thread" threading mode. This means that separate threads are allowed to use SQLite at the same time, as long as each thread is using a different database connection.
-	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_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       // The database is created if it does not already exist
+	SQLITE_OPEN_URI          OpenFlags = C.SQLITE_OPEN_URI          // The filename can be interpreted as a URI if this flag is set.
+	SQLITE_OPEN_MEMORY       OpenFlags = C.SQLITE_OPEN_MEMORY       // The database will be opened as an in-memory database. The database is named by the "filename" argument for the purposes of cache-sharing, if shared cache mode is enabled, but the "filename" is otherwise ignored.
+	SQLITE_OPEN_NOMUTEX      OpenFlags = C.SQLITE_OPEN_NOMUTEX      // The new database connection will use the "multi-thread" threading mode. This means that separate threads are allowed to use SQLite at the same time, as long as each thread is using a different database connection.
+	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_MIN = SQLITE_OPEN_READONLY
 	SQLITE_OPEN_MAX = SQLITE_OPEN_PRIVATECACHE
@@ -56,7 +56,7 @@ const (
 const (
 	DefaultSchema = "main"
 	DefaultMemory = ":memory:"
-	DefaultFlags  = SQLITE_OPEN_CREATE
+	DefaultFlags  = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE
 )
 
 func init() {

sys/sqlite3/connex.go

@@ -51,6 +51,7 @@ import "C"
 
 import (
 	"errors"
+	"fmt"
 	"reflect"
 	"sync"
 	"time"
@@ -503,6 +504,7 @@ func go_authorizer_hook(userInfo unsafe.Pointer, op C.int, a1, a2, a3, a4 *C.cha
 
 //export go_exec_handler
 func go_exec_handler(userInfo unsafe.Pointer, nargs C.int, row, cols **C.char) C.int {
+	fmt.Println("nargs=", nargs, "row=", row, "cols=", cols)
 	if c := cb.get(uintptr(userInfo)); c != nil && c.ExecFunc != nil {
 		return C.int(boolToInt(c.ExecFunc(go_string_slice(int(nargs), row), go_string_slice(int(nargs), cols))))
 	} else {