feat: timestamp & date

- fix timestamp or date type as go query parameters.
- basic facility to support SQL Null as input or output.
- more tests

.github/workflows/go.yml

@@ -15,7 +15,7 @@ jobs:
 
       - uses: actions/setup-go@v5
         with:
-          go-version: '^1.18'
+          go-version: '^1.22'
 
       - name: OpenMLDB cluster
         run: |
@@ -33,7 +33,7 @@ jobs:
           docker compose -f docker-compose.yml exec openmldb-ns1 /opt/openmldb/bin/openmldb --zk_cluster=openmldb-zk:2181 --zk_root_path=/openmldb --role=sql_client --cmd 'SET GLOBAL execute_mode = "online"'
 
       - name: go test
-        run: go test ./... -race -covermode=atomic -coverprofile=coverage.out
+        run: go test ./... -race -covermode=atomic -coverprofile=coverage.out -v
 
       - name: Coverage
         uses: codecov/codecov-action@v4

conn.go

@@ -3,6 +3,7 @@ package openmldb
 import (
 	"bytes"
 	"context"
+	"database/sql"
 	"database/sql/driver"
 	"encoding/json"
 	"errors"
@@ -71,7 +72,7 @@ type queryResp struct {
 }
 
 type respData struct {
-	Schema []string             `json:"schema"`
+	Schema []string         `json:"schema"`
 	Data   [][]driver.Value `json:"data"`
 }
 
@@ -127,36 +128,47 @@ type queryReq struct {
 }
 
 type queryInput struct {
-	Schema []string           `json:"schema"`
+	Schema []string       `json:"schema"`
 	Data   []driver.Value `json:"data"`
 }
 
-func marshalQueryRequest(mode, sql string, input ...driver.Value) ([]byte, error) {
+func marshalQueryRequest(mode string, sqlStr string, input ...driver.Value) ([]byte, error) {
 	req := queryReq{
 		Mode: mode,
-		SQL:  sql,
+		SQL:  sqlStr,
 	}
 
+	// TODO(someone): type infer from input slice do not always work. For example, a int type can be
+	// a int32 or int64, depends on value size. Also we're not covering more input types like uint.
+	// A better approach is to ask the schema types from api server, which in turn ask types info to SQL compiler.
+	//
+	// Another is that for a int16 or int32 input from DB.Query(...), it always convert to int64 because driver.Value
+	// only expect int64 from primitive types.
+
 	if len(input) > 0 {
 		schema := make([]string, len(input))
+		// TODO(someone): support value as nil, at current time it is not possible to infer SQL type from a nil
 		for i, v := range input {
-			switch v.(type) {
-			case bool:
+			switch vv := v.(type) {
+			case bool, Null[bool]:
 				schema[i] = "bool"
-			case int16:
+			case int16, Null[int16]:
 				schema[i] = "int16"
-			case int32:
+			case int32, Null[int32]:
 				schema[i] = "int32"
-			case int64:
+			case int64, Null[int64]:
 				schema[i] = "int64"
-			case float32:
+			case float32, Null[float32]:
 				schema[i] = "float"
-			case float64:
+			case float64, Null[float64]:
 				schema[i] = "double"
-			case string:
+			case string, Null[string]:
 				schema[i] = "string"
 			case time.Time:
 				schema[i] = "timestamp"
+				input[i] = Null[time.Time]{Null: sql.Null[time.Time]{V: vv, Valid: true}}
+			case Null[time.Time]:
+				schema[i] = "timestamp"
 			case NullDate:
 				schema[i] = "date"
 			default:
@@ -179,8 +191,14 @@ func unmarshalQueryResponse(respBody io.Reader) (*queryResp, error) {
 	}
 
 	if r.Data != nil {
+		// queryResp.Data may nil for DDL
 		for _, row := range r.Data.Data {
 			for i, col := range row {
+				if col == nil {
+					row[i] = nil
+					continue
+				}
+
 				switch strings.ToLower(r.Data.Schema[i]) {
 				case "bool":
 					row[i] = col.(bool)
@@ -196,14 +214,17 @@ func unmarshalQueryResponse(respBody io.Reader) (*queryResp, error) {
 					row[i] = float64(col.(float64))
 				case "string":
 					row[i] = col.(string)
+				// date and timestamp values saved internally as time.Time
 				case "timestamp":
 					// timestamp value returned as int64 millisecond unix epoch time
 					row[i] = time.UnixMilli(int64(col.(float64)))
 				case "date":
-					// date values returned as "YYYY-mm-dd" formated string
-					var nullDate NullDate
-					nullDate.Scan(col.(string))
-					row[i] = nullDate
+					t, err := parseDateStr(col.(string))
+					if err != nil {
+						row[i] = nil
+					}
+
+					row[i] = t
 				default:
 					return nil, fmt.Errorf("unknown type %s at index %d", r.Data.Schema[i], i)
 				}
@@ -244,7 +265,7 @@ func (c *conn) execute(ctx context.Context, sql string, parameters ...driver.Val
 	if r, err := unmarshalQueryResponse(resp.Body); err != nil {
 		return nil, err
 	} else if r.Code != 0 {
-		return nil, fmt.Errorf("conn error: %s", r.Msg)
+		return nil, fmt.Errorf("execute error: %s", r.Msg)
 	} else if r.Data != nil {
 		return &respDataRows{*r.Data, 0}, nil
 	}

conn_test.go

@@ -1,9 +1,11 @@
 package openmldb
 
 import (
-	interfaces "database/sql/driver"
+	"database/sql"
+	"database/sql/driver"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -12,28 +14,36 @@ func TestParseReqToJson(t *testing.T) {
 	for _, tc := range []struct {
 		mode   string
 		sql    string
-		input  []interfaces.Value
+		input  []driver.Value
 		expect string
 	}{
 		{
-			"offsync",
+			"offline",
 			"SELECT 1;",
 			nil,
 			`{
-				"mode": "offsync",
+				"mode": "offline",
 				"sql": "SELECT 1;"
 			}`,
 		},
 		{
-			"offsync",
+			"online",
 			"SELECT c1, c2 FROM demo WHERE c1 = ? AND c2 = ?;",
-			[]interfaces.Value{int32(1), "bb"},
+			[]driver.Value{
+				int16(2), // int16
+				int32(1), // int32
+				"bb",     // string
+				Null[string]{Null: sql.Null[string]{V: "foo", Valid: true}}, // string
+				time.UnixMilli(8000), // timestamp
+				Null[time.Time]{Null: sql.Null[time.Time]{V: time.UnixMilli(4000), Valid: true}},                              // timestamp
+				Null[time.Time]{Null: sql.Null[time.Time]{V: time.UnixMilli(4000), Valid: false}},                             // timestamp
+				NullDate{Null: sql.Null[time.Time]{V: time.Date(2022, time.October, 10, 0, 0, 0, 0, time.UTC), Valid: true}}}, // date
 			`{
-				"mode": "offsync",
+				"mode": "online",
 				"sql": "SELECT c1, c2 FROM demo WHERE c1 = ? AND c2 = ?;",
 				"input": {
-					"schema": ["int32", "string"],
-					"data": [1, "bb"]
+					"schema": ["int16", "int32", "string", "string", "timestamp", "timestamp", "timestamp", "date"],
+					"data": [2, 1, "bb", "foo", 8000, 4000, null, "2022-10-10"]
 				}
 			}`,
 		},
@@ -60,6 +70,24 @@ func TestParseRespFromJson(t *testing.T) {
 				Data: nil,
 			},
 		},
+		{
+			`{
+				"code": 0,
+				"msg": "ok",
+				"data": {
+					"schema": ["date", "string"],
+					"data": []
+				}
+			}`,
+			queryResp{
+				Code: 0,
+				Msg:  "ok",
+				Data: &respData{
+					Schema: []string{"date", "string"},
+					Data:   [][]driver.Value{},
+				},
+			},
+		},
 		{
 			`{
 				"code": 0,
@@ -74,7 +102,7 @@ func TestParseRespFromJson(t *testing.T) {
 				Msg:  "ok",
 				Data: &respData{
 					Schema: []string{"Int32", "String"},
-					Data: [][]interfaces.Value{
+					Data: [][]driver.Value{
 						{int32(1), "bb"},
 						{int32(2), "bb"},
 					},
@@ -95,7 +123,7 @@ func TestParseRespFromJson(t *testing.T) {
 				Msg:  "ok",
 				Data: &respData{
 					Schema: []string{"Bool", "Int16", "Int32", "Int64", "Float", "Double", "String"},
-					Data: [][]interfaces.Value{
+					Data: [][]driver.Value{
 						{true, int16(1), int32(1), int64(1), float32(1), float64(1), "bb"},
 					},
 				},

encode.go

@@ -0,0 +1,15 @@
+package openmldb
+
+import (
+	"time"
+)
+
+func parseDateStr(src string) (time.Time, error) {
+	// api server returns date type as string formatted 'yyyy-mm-dd'
+	dval, err := time.Parse(time.DateOnly, src)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	return dval, nil
+}

go.mod

@@ -1,6 +1,6 @@
 module github.com/4paradigm/openmldb-go-sdk
 
-go 1.18
+go 1.22
 
 require github.com/stretchr/testify v1.9.0