Updated

Author: djthorpe

pkg/sqlite3/results.go

@@ -8,8 +8,10 @@ import (
 
 	// Packages
 	sqlite3 "github.com/djthorpe/go-sqlite/sys/sqlite3"
+
 	// Namespace imports
-	//. "github.com/djthorpe/go-errors"
+	. "github.com/djthorpe/go-sqlite"
+	. "github.com/djthorpe/go-sqlite/pkg/lang"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -96,3 +98,26 @@ func (r *Results) RowsAffected() int {
 		return r.results.RowsAffected()
 	}
 }
+
+// Return the columns for the current results
+func (r *Results) Columns() []SQColumn {
+	if r.results == nil {
+		return nil
+	}
+	cols := make([]SQColumn, r.results.ColumnCount())
+	for i := range cols {
+		cols[i] = C(r.results.ColumnName(i)).WithType(r.results.ColumnDeclType(i))
+	}
+	return cols
+}
+
+func (r *Results) ColumnSource(i int) (string, string, string) {
+	if r.results == nil {
+		return "", "", ""
+	}
+	schema, table, name := r.results.ColumnDatabaseName(i), r.results.ColumnTableName(i), r.results.ColumnName(i)
+	if name == "" {
+		name = r.results.ColumnOriginName(i)
+	}
+	return schema, table, name
+}

plugin/sqlite3/README.md

@@ -75,8 +75,13 @@ Errors are returned when the status code is not `200 OK`. A typical error respon
 }
 ```
 
+## Plugin Configuration
 
-## Ping Request and Response
+TODO
+
+## Requests and Responses
+
+### Ping Request and Response
 
 There are no query arguments for this call. Typically a response will look like this:
 
@@ -107,11 +112,20 @@ There are no query arguments for this call. Typically a response will look like
 }
 ```
 
-## Schema Request and Response
+### Schema Request and Response
 
 There are no query arguments for this call. Typically a response will provide you with information
 in the schemas. For example, a typical response may look like this:
 
 TODO
 
-## Table Request and Response
+### Table Request and Response
+
+TODO
+
+### Query Request and Response
+
+TODO
+
+### Tokenizer Request and Response
+

plugin/sqlite3/handlers.go

@@ -58,11 +58,11 @@ type SchemaTableResponse struct {
 
 type SchemaColumnResponse struct {
 	Name     string `json:"name"`
-	Table    string `json:"table"`
-	Schema   string `json:"schema"`
-	Type     string `json:"type"`
-	Primary  bool   `json:"primary"`
-	Nullable bool   `json:"nullable"`
+	Table    string `json:"table,omitempty"`
+	Schema   string `json:"schema,omitempty"`
+	Type     string `json:"type,omitempty"`
+	Primary  bool   `json:"primary,omitempty"`
+	Nullable bool   `json:"nullable,omitempty"`
 }
 
 type SchemaIndexResponse struct {
@@ -76,12 +76,13 @@ type SqlRequest struct {
 }
 
 type SqlResultResponse struct {
-	Schema       string        `json:"schema,omitempty"`
-	Table        string        `json:"table,omitempty"`
-	Sql          string        `json:"sql"`
-	LastInsertId int64         `json:"last_insert_id,omitempty"`
-	RowsAffected int           `json:"rows_affected,omitempty"`
-	Result       []interface{} `json:"result,omitempty"`
+	Schema       string                 `json:"schema,omitempty"`
+	Table        string                 `json:"table,omitempty"`
+	Sql          string                 `json:"sql"`
+	LastInsertId int64                  `json:"last_insert_id,omitempty"`
+	RowsAffected int                    `json:"rows_affected,omitempty"`
+	Columns      []SchemaColumnResponse `json:"columns,omitempty"`
+	Results      []interface{}          `json:"results,omitempty"`
 }
 
 type TokenizerResponse struct {
@@ -213,16 +214,7 @@ func (p *plugin) ServeSchema(w http.ResponseWriter, req *http.Request) {
 			})
 		}
 		for _, column := range conn.ColumnsForTable(params[0], name) {
-			col := SchemaColumnResponse{
-				Name:   column.Name(),
-				Table:  name,
-				Schema: params[0],
-				Type:   column.Type(),
-			}
-			if column.Primary() != "" {
-				col.Primary = true
-			}
-			table.Columns = append(table.Columns, col)
+			table.Columns = append(table.Columns, schemaColumn(params[0], name, column))
 		}
 		response.Tables = append(response.Tables, table)
 	}
@@ -265,6 +257,9 @@ func (p *plugin) ServeTable(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
+	// Fix limit to ensure we only steam up to 1K results
+	q.Limit = uintMin(q.Limit, maxResultLimit)
+
 	// Populate response
 	var response SqlResultResponse
 	if err := conn.Do(req.Context(), SQLITE_TXN_DEFAULT, func(txn SQTransaction) error {
@@ -372,23 +367,44 @@ func (p *plugin) ServeQuery(w http.ResponseWriter, req *http.Request) {
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
+func schemaColumn(schema, table string, column SQColumn) SchemaColumnResponse {
+	result := SchemaColumnResponse{
+		Name:   column.Name(),
+		Table:  table,
+		Schema: schema,
+		Type:   column.Type(),
+	}
+	if column.Primary() != "" {
+		result.Primary = true
+	}
+	return result
+}
+
 func results(r SQResults) (SqlResultResponse, error) {
 	result := SqlResultResponse{
 		Sql:          r.ExpandedSQL(),
 		LastInsertId: r.LastInsertId(),
 		RowsAffected: r.RowsAffected(),
+		Columns:      []SchemaColumnResponse{},
+	}
+
+	// Set the columns
+	for i, column := range r.Columns() {
+		schema, table, _ := r.ColumnSource(i)
+		result.Columns = append(result.Columns, schemaColumn(schema, table, column))
 	}
 
 	// Iterate through the rows, break when maximum number of results is reached
 	for {
-		if row, err := r.Next(); errors.Is(err, io.EOF) {
+		row, err := r.Next()
+		if errors.Is(err, io.EOF) {
 			break
 		} else if err != nil {
 			return result, err
 		} else {
-			result.Result = append(result.Result, row)
+			result.Results = append(result.Results, interfaceSliceCopy(row))
 		}
-		if len(result.Result) >= maxResultLimit {
+		if len(result.Results) >= maxResultLimit {
 			break
 		}
 	}
@@ -397,6 +413,12 @@ func results(r SQResults) (SqlResultResponse, error) {
 	return result, nil
 }
 
+func interfaceSliceCopy(v []interface{}) []interface{} {
+	result := make([]interface{}, len(v))
+	copy(result, v)
+	return result
+}
+
 func stringSliceContainsElement(v []string, elem string) bool {
 	for _, v := range v {
 		if v == elem {

plugin/sqlite3/util.go

@@ -0,0 +1,9 @@
+package main
+
+// uintMin returns the minimum of two uints
+func uintMin(a, b uint) uint {
+	if a < b {
+		return a
+	}
+	return b
+}

sqlite.go

@@ -96,7 +96,8 @@ type SQTransaction interface {
 type SQResults interface {
 	// Return next row, returns nil when all rows consumed
 	// if types are provided, then returned row is cast to
-	// appopriate types
+	// appopriate types. The returned row needs to be copied
+	// if not transient
 	Next(...reflect.Type) ([]interface{}, error)
 
 	// Return next map of values, or nil if no more rows
@@ -113,6 +114,12 @@ type SQResults interface {
 
 	// Return number of changes made of last statement
 	RowsAffected() int
+
+	// Columns returns the column definitions
+	Columns() []SQColumn
+
+	// ColumnTable returns the schema, table and column name for a column index
+	ColumnSource(int) (string, string, string)
 }
 
 // SQAuth is an interface for authenticating an action

sys/sqlite3/connex.go

@@ -369,9 +369,10 @@ func (c *ConnEx) ExecEx(q string, fn ExecFunc, v ...interface{}) error {
 
 		// Cast row values to string
 		t := make([]reflect.Type, r.ColumnCount())
-		n := r.ColumnNames()
+		n := make([]string, r.ColumnCount())
 		v := make([]string, r.ColumnCount())
 		for i := range t {
+			n[i] = r.ColumnName(i)
 			t[i] = typeText
 		}
 

sys/sqlite3/results.go

@@ -130,87 +130,57 @@ func (r *Results) ExpandedSQL() string {
 	}
 }
 
-// Return column names for the next row to be fetched
-func (r *Results) ColumnNames() []string {
-	if r.st == nil {
-		return nil
-	}
-	len := r.st.ColumnCount()
-	result := make([]string, len)
-	for i := 0; i < len; i++ {
-		result[i] = r.st.ColumnName(i)
-	}
-	return result
-}
-
 // Return column count
 func (r *Results) ColumnCount() int {
 	return r.st.ColumnCount()
 }
 
-// Return column types for the next row to be fetched
-func (r *Results) ColumnTypes() []Type {
+// Return column name
+func (r *Results) ColumnName(i int) string {
 	if r.st == nil {
-		return nil
-	}
-	len := r.st.ColumnCount()
-	result := make([]Type, len)
-	for i := 0; i < len; i++ {
-		result[i] = r.st.ColumnType(i)
+		return ""
 	}
-	return result
+	return r.st.ColumnName(i)
 }
 
-// Return column decltypes for the next row to be fetched
-func (r *Results) ColumnDeclTypes() []string {
+// Return column type
+func (r *Results) ColumnType(i int) Type {
 	if r.st == nil {
-		return nil
+		return SQLITE_NULL
 	}
-	len := r.st.ColumnCount()
-	result := make([]string, len)
-	for i := 0; i < len; i++ {
-		result[i] = r.st.ColumnDeclType(i)
-	}
-	return result
+	return r.st.ColumnType(i)
 }
 
-// Return the source database schema name for the next row to be fetched
-func (r *Results) ColumnDatabaseNames() []string {
+// Return column decltype
+func (r *Results) ColumnDeclType(i int) string {
 	if r.st == nil {
-		return nil
-	}
-	len := r.st.ColumnCount()
-	result := make([]string, len)
-	for i := 0; i < len; i++ {
-		result[i] = r.st.ColumnDatabaseName(i)
+		return ""
 	}
-	return result
+	return r.st.ColumnDeclType(i)
 }
 
-// Return the source table name for the next row to be fetched
-func (r *Results) ColumnTableNames() []string {
+// Return the source database schema name
+func (r *Results) ColumnDatabaseName(i int) string {
 	if r.st == nil {
-		return nil
-	}
-	len := r.st.ColumnCount()
-	result := make([]string, len)
-	for i := 0; i < len; i++ {
-		result[i] = r.st.ColumnTableName(i)
+		return ""
 	}
-	return result
+	return r.st.ColumnDatabaseName(i)
 }
 
-// Return the origin for the next row to be fetched
-func (r *Results) ColumnOriginNames() []string {
+// Return the source table name
+func (r *Results) ColumnTableName(i int) string {
 	if r.st == nil {
-		return nil
+		return ""
 	}
-	len := r.st.ColumnCount()
-	result := make([]string, len)
-	for i := 0; i < len; i++ {
-		result[i] = r.st.ColumnOriginName(i)
+	return r.st.ColumnTableName(i)
+}
+
+// Return the origin
+func (r *Results) ColumnOriginName(i int) string {
+	if r.st == nil {
+		return ""
 	}
-	return result
+	return r.st.ColumnOriginName(i)
 }
 
 ///////////////////////////////////////////////////////////////////////////////