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

Author: proofrock

README.md

@@ -19,8 +19,9 @@ ws4sqlite --db mydatabase.db
 
 It's possible to make a POST call to `http://localhost:12321/mydatabase`, e.g. with the following body:
 
-```json
+```json5
 {
+    "resultFormat": "map", // "map" or "list"; if omitted, "map"
     "transaction": [
         {
             "statement": "INSERT INTO TEST_TABLE (ID, VAL, VAL2) VALUES (:id, :val, :val2)",
@@ -63,6 +64,8 @@ Obtaining an answer of
 - [**In-memory DBs**](https://germ.gitbook.io/ws4sqlite/documentation/configuration-file#path)  are supported;
 - Serving of [**multiple databases**](https://germ.gitbook.io/ws4sqlite/documentation/configuration-file) in the same server instance;
 - [**Batching**](https://germ.gitbook.io/ws4sqlite/documentation/requests#batch-parameter-values-for-a-statement) of multiple value sets for a single statement;
+- **Parameters** may be passed to statements positionally (lists) or by name (maps);
+- **Results** of queries may be returned as key-value maps, or as values lists;
 - All queries of a call are executed in a [**transaction**](https://germ.gitbook.io/ws4sqlite/documentation/requests);
 - For each query/statement, specify if a failure should rollback the whole transaction, or the failure is [**limited**](https://germ.gitbook.io/ws4sqlite/documentation/errors#managed-errors) to that query;
 - "[**Stored Statements**](https://germ.gitbook.io/ws4sqlite/documentation/stored-statements)": define SQL in the server, and call it from the client;

src/sched_tasks_test.go

@@ -18,11 +18,12 @@ 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
@@ -236,7 +237,7 @@ func TestSchedTasksWithStatement(t *testing.T) {
 		t.Error("did not succeed, but should have")
 	}
 
-	if fmt.Sprint(getDefault[float64](res.Results[0].ResultSet[0], "num")) != "17" {
+	if fmt.Sprint(res.Results[0].ResultSet[0].(map[string]interface{})["num"]) != "17" {
 		t.Error("scheduled statement probably didn't execute")
 	}
 }

src/structs.go

@@ -21,8 +21,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"sync"
-
-	"github.com/iancoleman/orderedmap"
 )
 
 // This is the ws4sqlite error type
@@ -116,8 +114,9 @@ type requestItem struct {
 }
 
 type request struct {
-	Credentials *credentials  `json:"credentials"`
-	Transaction []requestItem `json:"transaction"`
+	ResultFormat *string       `json:"resultFormat"`
+	Credentials  *credentials  `json:"credentials"`
+	Transaction  []requestItem `json:"transaction"`
 }
 
 type requestParams struct {
@@ -128,11 +127,12 @@ 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"`
-	ResultSet        []orderedmap.OrderedMap `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        []interface{} `json:"resultSet,omitnil"` // omitnil is used by jettison
+	Error            string        `json:"error,omitempty"`
 }
 
 type response struct {

src/web_service.go

@@ -57,14 +57,14 @@ 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, capitalize(err.Error())}
+	results[reqIdx] = responseItem{false, 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, params requestParams) (*responseItem, error) {
-	resultSet := make([]orderedmap.OrderedMap, 0)
+func processWithResultSet(tx *sql.Tx, query string, isListResultSet bool, params requestParams) (*responseItem, error) {
+	resultSet := make([]interface{}, 0)
 
 	rows := (*sql.Rows)(nil)
 	err := (error)(nil)
@@ -91,19 +91,29 @@ func processWithResultSet(tx *sql.Tx, query string, params requestParams) (*resp
 			return nil, err
 		}
 
-		toAdd := orderedmap.New()
-		for i := range values {
-			toAdd.Set(fields[i], values[i])
-		}
+		if isListResultSet {
+			// List-style result set
+			toAdd := make([]interface{}, 0)
+			for i := range values {
+				toAdd = append(toAdd, values[i])
+			}
+			resultSet = append(resultSet, toAdd)
+		} else {
+			// Map-style result set
+			toAdd := orderedmap.New()
+			for i := range values {
+				toAdd.Set(fields[i], values[i])
+			}
 
-		resultSet = append(resultSet, *toAdd)
+			resultSet = append(resultSet, *toAdd)
+		}
 	}
 
 	if err = rows.Err(); err != nil {
 		return nil, err
 	}
 
-	return &responseItem{true, nil, nil, resultSet, ""}, nil
+	return &responseItem{true, nil, nil, fields, resultSet, ""}, nil
 }
 
 // Process a single statement, and returns a suitable responseItem
@@ -126,7 +136,7 @@ func processForExec(tx *sql.Tx, statement string, params requestParams) (*respon
 		return nil, err
 	}
 
-	return &responseItem{true, &rowsUpdated, nil, nil, ""}, nil
+	return &responseItem{true, &rowsUpdated, nil, nil, nil, ""}, nil
 }
 
 // Process a batch statement, and returns a suitable responseItem.
@@ -161,7 +171,7 @@ func processForExecBatch(tx *sql.Tx, q string, paramsBatch []requestParams) (*re
 		rowsUpdatedBatch = append(rowsUpdatedBatch, rowsUpdated)
 	}
 
-	return &responseItem{true, nil, rowsUpdatedBatch, nil, ""}, nil
+	return &responseItem{true, nil, rowsUpdatedBatch, nil, nil, ""}, nil
 }
 
 func ckSQL(sql string) string {
@@ -187,6 +197,8 @@ func handler(databaseId string) func(c *fiber.Ctx) error {
 			return newWSError(-1, fiber.StatusBadRequest, "in parsing body: %s", err.Error())
 		}
 
+		isListResultSet := body.ResultFormat != nil && strings.EqualFold(*body.ResultFormat, "list")
+
 		db, found := dbs[databaseId]
 		if !found {
 			return newWSError(-1, fiber.StatusNotFound, "database with ID '%s' not found", databaseId)
@@ -309,7 +321,7 @@ func handler(databaseId string) func(c *fiber.Ctx) error {
 				if hasResultSet {
 					// Query
 					// Externalized in a func so that defer rows.Close() actually runs
-					retWR, err := processWithResultSet(tx, sqll, *params)
+					retWR, err := processWithResultSet(tx, sqll, isListResultSet, *params)
 					if err != nil {
 						reportError(err, fiber.StatusInternalServerError, i, txItem.NoFail, ret.Results)
 						continue

src/ws4sqlite_test.go

@@ -18,13 +18,14 @@ package main
 
 import (
 	"encoding/json"
-	"github.com/gofiber/fiber/v2"
 	"os"
 	"slices"
 	"sync"
 	"testing"
 	"time"
 
+	"github.com/gofiber/fiber/v2"
+
 	mllog "github.com/proofrock/go-mylittlelogger"
 )
 
@@ -221,7 +222,7 @@ func TestTx(t *testing.T) {
 		t.Error("req 1 inconsistent")
 	}
 
-	if !res.Results[2].Success || getDefault[string](res.Results[2].ResultSet[0], "VAL") != "ONE" {
+	if !res.Results[2].Success || res.Results[2].ResultSet[0].(map[string]interface{})["VAL"] != "ONE" {
 		t.Error("req 2 inconsistent")
 	}
 
@@ -364,7 +365,7 @@ func TestConcurrent(t *testing.T) {
 				t.Error("req 1 inconsistent")
 			}
 
-			if !res.Results[2].Success || getDefault[string](res.Results[2].ResultSet[0], "VAL") != "ONE" {
+			if !res.Results[2].Success || res.Results[2].ResultSet[0].(map[string]interface{})["VAL"] != "ONE" {
 				t.Error("req 2 inconsistent")
 			}
 
@@ -417,10 +418,11 @@ func TestResultSetOrder(t *testing.T) {
 		return
 	}
 
-	queryResult := res.Results[2].ResultSet[0]
+	queryResult := res.Results[2].ResultSet[0].(map[string]interface{})
+	queryResultHeaders := res.Results[2].ResultHeaders
 	expectedKeys := []string{"d", "c", "b", "a"}
 	if !slices.Equal(
-		queryResult.Keys(),
+		queryResultHeaders,
 		expectedKeys,
 	) {
 		t.Error("should have the right order")
@@ -429,7 +431,7 @@ func TestResultSetOrder(t *testing.T) {
 
 	expectedValues := []float64{4, 3, 2, 1}
 	for i, key := range expectedKeys {
-		value, ok := queryResult.Get(key)
+		value, ok := queryResult[key]
 		if !ok {
 			t.Error("unreachable code")
 			return
@@ -442,6 +444,64 @@ func TestResultSetOrder(t *testing.T) {
 	}
 }
 
+var listResults string = "list"
+
+func TestListResultSet(t *testing.T) {
+	// See this issue for more context: https://github.com/proofrock/sqliterg/issues/5
+	req := request{
+		ResultFormat: &listResults,
+		Transaction: []requestItem{
+			{
+				Statement: "CREATE TABLE table_with_many_columns (d INT, c INT, b INT, a INT)",
+			},
+			{
+				Statement: "INSERT INTO table_with_many_columns VALUES (4, 3, 2, 1)",
+			},
+			{
+				Query: "SELECT * FROM table_with_many_columns",
+			},
+			{
+				Statement: "DROP TABLE table_with_many_columns",
+			},
+		},
+	}
+	code, _, res := call("test", req, t)
+
+	if code != 200 {
+		t.Error("did not succeed")
+		return
+	}
+
+	if !res.Results[0].Success ||
+		!res.Results[1].Success ||
+		!res.Results[2].Success ||
+		!res.Results[3].Success {
+		t.Error("did not succeed")
+		return
+	}
+
+	queryResult := res.Results[2].ResultSet[0].([]interface{})
+	queryResultHeaders := res.Results[2].ResultHeaders
+	expectedKeys := []string{"d", "c", "b", "a"}
+	if !slices.Equal(
+		queryResultHeaders,
+		expectedKeys,
+	) {
+		t.Error("should have the right order")
+		return
+	}
+
+	expectedValues := []float64{4, 3, 2, 1}
+	for i, key := range expectedKeys {
+		value := queryResult[slices.Index(queryResultHeaders, key)]
+		expectedValue := expectedValues[i]
+		if value != expectedValue {
+			t.Error("wrong value")
+			return
+		}
+	}
+}
+
 func TestArrayParams(t *testing.T) {
 	req := request{
 		Transaction: []requestItem{
@@ -550,7 +610,7 @@ func TestOkRO(t *testing.T) {
 		return
 	}
 
-	if !res.Results[0].Success || getDefault[string](res.Results[0].ResultSet[3], "VAL") != "FOUR" {
+	if !res.Results[0].Success || res.Results[0].ResultSet[3].(map[string]interface{})["VAL"] != "FOUR" {
 		t.Error("req is inconsistent")
 	}
 }
@@ -577,7 +637,7 @@ func TestConcurrentRO(t *testing.T) {
 				return
 			}
 
-			if !res.Results[0].Success || getDefault[string](res.Results[0].ResultSet[3], "VAL") != "FOUR" {
+			if !res.Results[0].Success || res.Results[0].ResultSet[3].(map[string]interface{})["VAL"] != "FOUR" {
 				t.Error("req is inconsistent")
 			}
 		}(t)
@@ -1312,7 +1372,7 @@ func TestUnicode(t *testing.T) {
 	if code != 200 {
 		t.Error("SELECT failed", body)
 	}
-	if getDefault[string](res.Results[0].ResultSet[0], "TXT") != "世界" {
+	if res.Results[0].ResultSet[0].(map[string]interface{})["TXT"] != "世界" {
 		t.Error("Unicode extraction failed", body)
 	}