#43: Option to return results as a list, instead of a map

Author: proofrock

src/sched_tasks_test.go

@@ -18,12 +18,11 @@ package main
 
 import (
 	"fmt"
+	"github.com/robfig/cron/v3"
 	"os"
 	"path/filepath"
 	"testing"
 	"time"
-
-	"github.com/robfig/cron/v3"
 )
 
 // The post-0.14 "scheduledTasks" structure is only actually tested in TestAtStartupMultiple, but the contents of the
@@ -237,7 +236,7 @@ func TestSchedTasksWithStatement(t *testing.T) {
 		t.Error("did not succeed, but should have")
 	}
 
-	if fmt.Sprint(res.Results[0].ResultSet[0].(map[string]interface{})["num"]) != "17" {
+	if fmt.Sprint(getDefault[float64](res.Results[0].ResultSet[0], "num")) != "17" {
 		t.Error("scheduled statement probably didn't execute")
 	}
 }

src/structs.go

@@ -21,6 +21,8 @@ import (
 	"encoding/json"
 	"fmt"
 	"sync"
+
+	"github.com/iancoleman/orderedmap"
 )
 
 // This is the ws4sqlite error type
@@ -127,12 +129,13 @@ type requestParams struct {
 // These are for generating the response
 
 type responseItem struct {
-	Success          bool          `json:"success"`
-	RowsUpdated      *int64        `json:"rowsUpdated,omitempty"`
-	RowsUpdatedBatch []int64       `json:"rowsUpdatedBatch,omitempty"`
-	ResultHeaders    []string      `json:"resultHeaders,omitempty"`
-	ResultSet        []interface{} `json:"resultSet,omitnil"` // omitnil is used by jettison
-	Error            string        `json:"error,omitempty"`
+	Success          bool                    `json:"success"`
+	RowsUpdated      *int64                  `json:"rowsUpdated,omitempty"`
+	RowsUpdatedBatch []int64                 `json:"rowsUpdatedBatch,omitempty"`
+	ResultHeaders    []string                `json:"resultHeaders,omitempty"`
+	ResultSet        []orderedmap.OrderedMap `json:"resultSet,omitnil"`     // omitnil is used by jettison
+	ResultSetList    [][]interface{}         `json:"resultSetList,omitnil"` // omitnil is used by jettison
+	Error            string                  `json:"error,omitempty"`
 }
 
 type response struct {

src/utils.go

@@ -21,13 +21,14 @@ import (
 	"database/sql"
 	"encoding/json"
 	"errors"
-	"github.com/iancoleman/orderedmap"
-	"github.com/mitchellh/go-homedir"
-	mllog "github.com/proofrock/go-mylittlelogger"
 	"os"
 	"path/filepath"
 	"slices"
 	"strings"
+
+	"github.com/iancoleman/orderedmap"
+	"github.com/mitchellh/go-homedir"
+	mllog "github.com/proofrock/go-mylittlelogger"
 )
 
 // Uppercases (?) the first letter of a string
@@ -57,20 +58,6 @@ func dirExists(dirname string) bool {
 	return info.IsDir()
 }
 
-// Maps the raw JSON messages to a proper map, to manage unstructured JSON parsing;
-// see https://noamt.medium.com/using-gos-json-rawmessage-a2371a1c11b7
-func raw2vals(raw map[string]json.RawMessage) (map[string]interface{}, error) {
-	ret := make(map[string]interface{})
-	for key, rawVal := range raw {
-		var val interface{}
-		if err := json.Unmarshal(rawVal, &val); err != nil {
-			return nil, err
-		}
-		ret[key] = val
-	}
-	return ret, nil
-}
-
 // Maps named parameters to the proper sql type, needed to use named params
 func vals2nameds(vals map[string]interface{}) []interface{} {
 	var nameds []interface{}
@@ -82,7 +69,7 @@ func vals2nameds(vals map[string]interface{}) []interface{} {
 
 func isEmptyRaw(raw json.RawMessage) bool {
 	// the last check is for `null`
-	return raw == nil || len(raw) == 0 || slices.Equal(raw, []byte{110, 117, 108, 108})
+	return len(raw) == 0 || slices.Equal(raw, []byte{110, 117, 108, 108})
 }
 
 func raw2params(raw json.RawMessage) (*requestParams, error) {

src/web_service.go

@@ -57,14 +57,15 @@ func reportError(err error, code int, reqIdx int, noFail bool, results []respons
 	if !noFail {
 		panic(newWSError(reqIdx, code, err.Error()))
 	}
-	results[reqIdx] = responseItem{false, nil, nil, nil, nil, capitalize(err.Error())}
+	results[reqIdx] = responseItem{false, nil, nil, nil, nil, nil, capitalize(err.Error())}
 }
 
 // Processes a query, and returns a suitable responseItem
 //
 // This method is needed to execute properly the defers.
 func processWithResultSet(tx *sql.Tx, query string, isListResultSet bool, params requestParams) (*responseItem, error) {
-	resultSet := make([]interface{}, 0)
+	resultSet := make([]orderedmap.OrderedMap, 0)
+	resultSetList := make([][]interface{}, 0)
 
 	rows := (*sql.Rows)(nil)
 	err := (error)(nil)
@@ -80,10 +81,10 @@ func processWithResultSet(tx *sql.Tx, query string, isListResultSet bool, params
 	}
 	defer rows.Close()
 
-	fields, _ := rows.Columns() // I can ignore the error, rows aren't closed
+	headers, _ := rows.Columns() // I can ignore the error, rows aren't closed
 	for rows.Next() {
-		values := make([]interface{}, len(fields)) // values of the various fields
-		scans := make([]interface{}, len(fields))  // pointers to the values, to pass to Scan()
+		values := make([]interface{}, len(headers)) // values of the various fields
+		scans := make([]interface{}, len(headers))  // pointers to the values, to pass to Scan()
 		for i := range values {
 			scans[i] = &values[i]
 		}
@@ -93,16 +94,14 @@ func processWithResultSet(tx *sql.Tx, query string, isListResultSet bool, params
 
 		if isListResultSet {
 			// List-style result set
-			toAdd := make([]interface{}, 0)
-			for i := range values {
-				toAdd = append(toAdd, values[i])
-			}
-			resultSet = append(resultSet, toAdd)
+
+			resultSetList = append(resultSetList, values)
 		} else {
 			// Map-style result set
+
 			toAdd := orderedmap.New()
 			for i := range values {
-				toAdd.Set(fields[i], values[i])
+				toAdd.Set(headers[i], values[i])
 			}
 
 			resultSet = append(resultSet, *toAdd)
@@ -113,7 +112,10 @@ func processWithResultSet(tx *sql.Tx, query string, isListResultSet bool, params
 		return nil, err
 	}
 
-	return &responseItem{true, nil, nil, fields, resultSet, ""}, nil
+	if isListResultSet {
+		return &responseItem{true, nil, nil, headers, nil, resultSetList, ""}, nil
+	}
+	return &responseItem{true, nil, nil, headers, resultSet, nil, ""}, nil
 }
 
 // Process a single statement, and returns a suitable responseItem
@@ -136,7 +138,7 @@ func processForExec(tx *sql.Tx, statement string, params requestParams) (*respon
 		return nil, err
 	}
 
-	return &responseItem{true, &rowsUpdated, nil, nil, nil, ""}, nil
+	return &responseItem{true, &rowsUpdated, nil, nil, nil, nil, ""}, nil
 }
 
 // Process a batch statement, and returns a suitable responseItem.
@@ -171,7 +173,7 @@ func processForExecBatch(tx *sql.Tx, q string, paramsBatch []requestParams) (*re
 		rowsUpdatedBatch = append(rowsUpdatedBatch, rowsUpdated)
 	}
 
-	return &responseItem{true, nil, rowsUpdatedBatch, nil, nil, ""}, nil
+	return &responseItem{true, nil, rowsUpdatedBatch, nil, nil, nil, ""}, nil
 }
 
 func ckSQL(sql string) string {

src/ws4sqlite_test.go

@@ -78,7 +78,7 @@ func callBA(databaseId string, req request, user, password string, t *testing.T)
 
 	code, bodyBytes, errs := post.Bytes()
 
-	if errs != nil && len(errs) > 0 {
+	if len(errs) > 0 {
 		t.Error(errs[0])
 	}
 
@@ -222,7 +222,7 @@ func TestTx(t *testing.T) {
 		t.Error("req 1 inconsistent")
 	}
 
-	if !res.Results[2].Success || res.Results[2].ResultSet[0].(map[string]interface{})["VAL"] != "ONE" {
+	if !res.Results[2].Success || getDefault[string](res.Results[2].ResultSet[0], "VAL") != "ONE" {
 		t.Error("req 2 inconsistent")
 	}
 
@@ -365,7 +365,7 @@ func TestConcurrent(t *testing.T) {
 				t.Error("req 1 inconsistent")
 			}
 
-			if !res.Results[2].Success || res.Results[2].ResultSet[0].(map[string]interface{})["VAL"] != "ONE" {
+			if !res.Results[2].Success || getDefault[string](res.Results[2].ResultSet[0], "VAL") != "ONE" {
 				t.Error("req 2 inconsistent")
 			}
 
@@ -418,11 +418,10 @@ func TestResultSetOrder(t *testing.T) {
 		return
 	}
 
-	queryResult := res.Results[2].ResultSet[0].(map[string]interface{})
-	queryResultHeaders := res.Results[2].ResultHeaders
+	queryResult := res.Results[2].ResultSet[0]
 	expectedKeys := []string{"d", "c", "b", "a"}
 	if !slices.Equal(
-		queryResultHeaders,
+		queryResult.Keys(),
 		expectedKeys,
 	) {
 		t.Error("should have the right order")
@@ -431,7 +430,7 @@ func TestResultSetOrder(t *testing.T) {
 
 	expectedValues := []float64{4, 3, 2, 1}
 	for i, key := range expectedKeys {
-		value, ok := queryResult[key]
+		value, ok := queryResult.Get(key)
 		if !ok {
 			t.Error("unreachable code")
 			return
@@ -480,7 +479,7 @@ func TestListResultSet(t *testing.T) {
 		return
 	}
 
-	queryResult := res.Results[2].ResultSet[0].([]interface{})
+	queryResult := res.Results[2].ResultSetList[0]
 	queryResultHeaders := res.Results[2].ResultHeaders
 	expectedKeys := []string{"d", "c", "b", "a"}
 	if !slices.Equal(
@@ -610,7 +609,7 @@ func TestOkRO(t *testing.T) {
 		return
 	}
 
-	if !res.Results[0].Success || res.Results[0].ResultSet[3].(map[string]interface{})["VAL"] != "FOUR" {
+	if !res.Results[0].Success || getDefault[string](res.Results[0].ResultSet[3], "VAL") != "FOUR" {
 		t.Error("req is inconsistent")
 	}
 }
@@ -637,7 +636,7 @@ func TestConcurrentRO(t *testing.T) {
 				return
 			}
 
-			if !res.Results[0].Success || res.Results[0].ResultSet[3].(map[string]interface{})["VAL"] != "FOUR" {
+			if !res.Results[0].Success || getDefault[string](res.Results[0].ResultSet[3], "VAL") != "FOUR" {
 				t.Error("req is inconsistent")
 			}
 		}(t)
@@ -1372,7 +1371,7 @@ func TestUnicode(t *testing.T) {
 	if code != 200 {
 		t.Error("SELECT failed", body)
 	}
-	if res.Results[0].ResultSet[0].(map[string]interface{})["TXT"] != "世界" {
+	if getDefault[string](res.Results[0].ResultSet[0], "TXT") != "世界" {
 		t.Error("Unicode extraction failed", body)
 	}
 
@@ -1499,7 +1498,7 @@ func TestFileServer(t *testing.T) {
 
 	code, _, errs := get.String()
 
-	if errs != nil && len(errs) > 0 {
+	if len(errs) > 0 {
 		t.Error(errs[0])
 	}
 
@@ -1526,7 +1525,7 @@ func TestFileServerKO(t *testing.T) {
 
 	code, _, errs := get.String()
 
-	if errs != nil && len(errs) > 0 {
+	if len(errs) > 0 {
 		t.Error(errs[0])
 	}
 
@@ -1553,7 +1552,7 @@ func TestFileServerWithOverlap(t *testing.T) {
 
 	code, _, errs := get.String()
 
-	if errs != nil && len(errs) > 0 {
+	if len(errs) > 0 {
 		t.Error(errs[0])
 	}